{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import heapq\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PriorityQueue:\n",
    "    def __init__(self):\n",
    "        self.pq = []\n",
    "        self.entry_finder = {}\n",
    "        self.REMOVED = '<removed-task>'\n",
    "        self.counter = 0\n",
    "    \n",
    "    def add_item(self, item, priority = 0):\n",
    "        if item in self.entry_finder:\n",
    "            self.remove_item(item)\n",
    "        \n",
    "        entry = [priority, self.counter, item]\n",
    "        self.counter += 1\n",
    "        self.entry_finder[item] = entry\n",
    "        heapq.heappush(self.pq, entry)\n",
    "    \n",
    "    def remove_item(self, item):\n",
    "        entry = self.entry_finder[item]\n",
    "        entry[-1] = self.REMOVED\n",
    "    \n",
    "    def pop_item(self):\n",
    "        while self.pq:\n",
    "            priority, counter, item = heapq.heappop(self.pq)\n",
    "            if item is not self.REMOVED:\n",
    "                del self.entry_finder[item]\n",
    "                return item, priority\n",
    "        raise KeyError('pop from an empty priority queue')\n",
    "\n",
    "    def empty(self):\n",
    "        return not self.entry_finder\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# A wrapper class for a maze, containing all the information about the maze.\n",
    "# Basically it's initialized to DynaMaze by default, however it can be easily adapted\n",
    "# to other maze\n",
    "class Maze:\n",
    "    def __init__(self):\n",
    "        # maze width\n",
    "        self.WORLD_WIDTH = 9\n",
    "        # maze height\n",
    "        self.WORLD_HEIGHT = 6\n",
    "\n",
    "        # all possible actions\n",
    "        self.ACTION_UP = 0\n",
    "        self.ACTION_DOWN = 1\n",
    "        self.ACTION_LEFT = 2\n",
    "        self.ACTION_RIGHT = 3\n",
    "        self.actions = [self.ACTION_UP, self.ACTION_DOWN, self.ACTION_LEFT, self.ACTION_RIGHT]\n",
    "\n",
    "        self.START_STATE = [2, 0]\n",
    "        self.GOAL_STATES = [[0, self.WORLD_WIDTH - 1]]\n",
    "\n",
    "        # all obstacles\n",
    "        self.obstacles = [[1, 2], [2, 2], [3, 2], [0, 7], [1, 7], [2, 7], [4, 5]]\n",
    "        self.old_obstacles = None\n",
    "        self.new_obstacles = None\n",
    "\n",
    "        # time to change obstacles\n",
    "        self.obstacle_switch_time = None\n",
    "\n",
    "        self.q_size = (self.WORLD_HEIGHT, self.WORLD_WIDTH, len(self.actions))\n",
    "\n",
    "        self.max_steps = float('inf')\n",
    "\n",
    "        self.resolution = 1\n",
    "    # extend a state to a higher resolution maze\n",
    "    # @state: state in lower resolution maze\n",
    "    # @factor: extension factor, one state will become factor^2 states after extension\n",
    "    def extend_state(self, state, factor):\n",
    "        new_state = [state[0] * factor, state[1] * factor]\n",
    "        new_states = []\n",
    "        for i in range(0, factor):\n",
    "            for j in range(0, factor):\n",
    "                new_states.append([new_state[0] + i, new_state[1] + j])\n",
    "        return new_states\n",
    "\n",
    "\n",
    "    # extend a state into higher resolution\n",
    "    # one state in original maze will become @factor^2 states in @return new maze\n",
    "    def extend_maze(self, factor):\n",
    "        new_maze = Maze()\n",
    "        new_maze.WORLD_WIDTH = self.WORLD_WIDTH * factor\n",
    "        new_maze.WORLD_HEIGHT = self.WORLD_HEIGHT * factor\n",
    "        new_maze.START_STATE = [self.START_STATE[0] * factor, self.START_STATE[1] * factor]\n",
    "        new_maze.GOAL_STATES = self.extend_state(self.GOAL_STATES[0], factor)\n",
    "        new_maze.obstacles = []\n",
    "        for state in self.obstacles:\n",
    "            new_maze.obstacles.extend(self.extend_state(state, factor))\n",
    "        new_maze.q_size = (new_maze.WORLD_HEIGHT, new_maze.WORLD_WIDTH, len(new_maze.actions))\n",
    "        new_maze.resolution = factor\n",
    "        return new_maze\n",
    "\n",
    "    def step(self, state, action):\n",
    "        \n",
    "        x, y = state\n",
    "        if action == self.ACTION_UP:\n",
    "            x = max(x - 1, 0)\n",
    "        elif action == self.ACTION_DOWN:\n",
    "            x = min(x + 1, self.WORLD_HEIGHT - 1)\n",
    "        elif action == self.ACTION_LEFT:\n",
    "            y = max(y - 1, 0)\n",
    "        elif action == self.ACTION_RIGHT:\n",
    "            y = min(y + 1, self.WORLD_WIDTH - 1)\n",
    "        if [x, y] in self.obstacles:\n",
    "            x, y = state\n",
    "        if [x, y] in self.GOAL_STATES:\n",
    "            reward = 1.0\n",
    "        else:\n",
    "            reward = 0.0\n",
    "        return [x, y], reward\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# a wrapper class for parameters of dyna algorithms\n",
    "class DynaParams:\n",
    "    def __init__(self):\n",
    "        # discount\n",
    "        self.gamma = 0.95\n",
    "\n",
    "        # probability for exploration\n",
    "        self.epsilon = 0.1\n",
    "\n",
    "        # step size\n",
    "        self.alpha = 0.1\n",
    "\n",
    "        # weight for elapsed time\n",
    "        self.time_weight = 0\n",
    "\n",
    "        # n-step planning\n",
    "        self.planning_steps = 5\n",
    "\n",
    "\n",
    "        # average over several independent runs\n",
    "        self.runs = 10\n",
    "\n",
    "        # algorithm names\n",
    "        self.methods = ['Dyna-Q', 'Dyna-Q+']\n",
    "\n",
    "        # threshold for priority queue\n",
    "        self.theta = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# choose an action based on epsilon-greedy algorithm\n",
    "def choose_action(state, q_value, maze:Maze, dyna_params:DynaParams):\n",
    "    if np.random.binomial(1, dyna_params.epsilon) == 1:\n",
    "        return np.random.choice(maze.actions)\n",
    "    else:\n",
    "        values = q_value[state[0], state[1], :]\n",
    "        return np.random.choice([action for action, value_ in enumerate(values) if value_ == np.max(values)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trivial model for planning in Dyna-Q\n",
    "class TrivialModel:\n",
    "    # @rand: an instance of np.random.RandomState for sampling\n",
    "    def __init__(self, rand=np.random):\n",
    "        self.model = dict()\n",
    "        self.rand = rand\n",
    "    \n",
    "    # feed the model with previous experience\n",
    "    def feed(self, state, action, next_state, reward):\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        if tuple(state) not in self.model.keys():\n",
    "            self.model[tuple(state)] = dict()\n",
    "        self.model[tuple(state)][action] = [list(next_state), reward]\n",
    "    \n",
    "    # randomly sample from previous experience\n",
    "    def sample(self):\n",
    "        state_index = self.rand.choice(range(len(self.model.keys())))\n",
    "        state = list(self.model)[state_index]\n",
    "        action_index = self.rand.choice(range(len(self.model[state].keys())))\n",
    "        action = list(self.model[state])[action_index]\n",
    "        next_state, reward = self.model[state][action]\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        return list(state), action, list(next_state), reward\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# play for an episode for Dyna-Q algorithm\n",
    "# @q_value: state action pair values, will be updated\n",
    "# @model: model instance for planning\n",
    "# @maze: a maze instance containing all information about the environment\n",
    "# @dyna_params: several params for the algorithm\n",
    "def dyna_q(q_value, model:TrivialModel, maze:Maze, dyna_params:DynaParams):\n",
    "    state = maze.START_STATE\n",
    "    steps = 0\n",
    "    while state not in maze.GOAL_STATES:\n",
    "        # track the steps\n",
    "        steps += 1\n",
    "        # get action\n",
    "        action = choose_action(state, q_value, maze, dyna_params)\n",
    "        # take action\n",
    "        next_state, reward = maze.step(state, action)\n",
    "        # Q-learning update\n",
    "        q_value[state[0], state[1], action] += \\\n",
    "            dyna_params.alpha * (reward + dyna_params.gamma * np.max(q_value[next_state[0], next_state[1], :]) \n",
    "                                 - q_value[state[0], state[1], action])\n",
    "        # feed the model with experience\n",
    "        model.feed(state, action, next_state, reward)\n",
    "\n",
    "\n",
    "        # sample experience from the model\n",
    "        for t in range(0, dyna_params.planning_steps):\n",
    "            state_, action_, next_state_, reward_ = model.sample()\n",
    "            q_value[state_[0], state_[1], action_] += \\\n",
    "                dyna_params.alpha * (reward_ + dyna_params.gamma * np.max(q_value[next_state_[0], next_state_[1], :]) \n",
    "                                    - q_value[state_[0], state_[1], action_])\n",
    "        state = next_state\n",
    "        # check whether it has exceeded the step limit\n",
    "        if steps > maze.max_steps:\n",
    "            break\n",
    "    return steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_maze(q_value, maze:Maze):\n",
    "    optimal_policy = []\n",
    "    for i in range(0, maze.WORLD_HEIGHT):\n",
    "        optimal_policy.append([])\n",
    "        for j in range(0, maze.WORLD_WIDTH):\n",
    "            if [i, j] in maze.GOAL_STATES:\n",
    "                optimal_policy[-1].append('G')\n",
    "                continue\n",
    "            if [i, j] in maze.obstacles:\n",
    "                optimal_policy[-1].append('O')\n",
    "                continue\n",
    "            bestAction = np.argmax(q_value[i, j, :])\n",
    "            if bestAction == maze.ACTION_UP:\n",
    "                optimal_policy[-1].append('↑')\n",
    "            elif bestAction == maze.ACTION_DOWN:\n",
    "                optimal_policy[-1].append('↓')\n",
    "            elif bestAction == maze.ACTION_LEFT:\n",
    "                optimal_policy[-1].append('←')\n",
    "            elif bestAction == maze.ACTION_RIGHT:\n",
    "                optimal_policy[-1].append('→')\n",
    "            else:\n",
    "                raise ValueError(f\"unknown action:{bestAction}\")\n",
    "    for row in optimal_policy:\n",
    "        print(row)\n",
    "    \n",
    "    optimal_policy = []\n",
    "    for i in range(0, maze.WORLD_HEIGHT):\n",
    "        optimal_policy.append([])\n",
    "        for j in range(0, maze.WORLD_WIDTH):\n",
    "            if [i, j] in maze.GOAL_STATES:\n",
    "                optimal_policy[-1].append('G')\n",
    "                continue\n",
    "            if [i, j] in maze.obstacles:\n",
    "                optimal_policy[-1].append('O')\n",
    "                continue\n",
    "            bestAction = np.argmax(q_value[i, j, :])\n",
    "            optimal_policy[-1].append('.')\n",
    "\n",
    "\n",
    "    \n",
    "    state = maze.START_STATE\n",
    "    STEP_NUM = 0\n",
    "    while state not in maze.GOAL_STATES:\n",
    "        i, j = state\n",
    "        bestAction = np.argmax(q_value[i, j, :])\n",
    "        if bestAction == maze.ACTION_UP:\n",
    "            optimal_policy[i][j] = '↑'\n",
    "        elif bestAction == maze.ACTION_DOWN:\n",
    "            optimal_policy[i][j] = '↓'\n",
    "        elif bestAction == maze.ACTION_LEFT:\n",
    "            optimal_policy[i][j] = '←'\n",
    "        elif bestAction == maze.ACTION_RIGHT:\n",
    "            optimal_policy[i][j] = '→'\n",
    "        else:\n",
    "            raise ValueError(f\"unknown action:{bestAction}\")\n",
    "        next_state, _ = maze.step(state, bestAction)\n",
    "        state = next_state\n",
    "        STEP_NUM += 1\n",
    "    print('Path is:', STEP_NUM)\n",
    "    for row in optimal_policy:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Figure 8.2, DynaMaze, use 10 runs instead of 30 runs\n",
    "def figure_8_2():\n",
    "    # set up an instance for DynaMaze\n",
    "    dyna_maze = Maze()\n",
    "    dyna_params = DynaParams()\n",
    "\n",
    "    runs = 10\n",
    "    episodes = 50\n",
    "    planning_steps = [0, 5, 50]\n",
    "    steps = np.zeros((len(planning_steps), episodes))\n",
    "\n",
    "    for run in tqdm(range(runs)):\n",
    "        for i, planning_step in enumerate(planning_steps):\n",
    "            dyna_params.planning_steps = planning_step\n",
    "            q_value = np.zeros(dyna_maze.q_size)\n",
    "\n",
    "            # generate an instance of Dyna-Q model\n",
    "            model = TrivialModel()\n",
    "            for ep in range(episodes):\n",
    "                # print('run:', run, 'planning step:', planning_step, 'episode:', ep)\n",
    "                steps[i, ep] += dyna_q(q_value, model, dyna_maze, dyna_params)\n",
    "            if run == range(runs)[-1]:\n",
    "                print(\"-\" * 10, end='')\n",
    "                print(f\"[{planning_step}]\", end='')\n",
    "                print(\"-\" * 10)\n",
    "                print_maze(q_value, dyna_maze)\n",
    "                print(\"-\" * 10, end='')\n",
    "                print(\"-\" * 10)\n",
    "    # averaging over runs\n",
    "    steps /= runs\n",
    "\n",
    "    for i in range(len(planning_steps)):\n",
    "        plt.plot(steps[i, :], label='%d planning steps' % (planning_steps[i]))\n",
    "    plt.xlabel('episodes')\n",
    "    plt.ylabel('steps per episode')\n",
    "    plt.legend()\n",
    "\n",
    "    # plt.savefig('../images/figure_8_2.png')\n",
    "    # plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 9/10 [00:37<00:03,  3.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------[0]----------\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', 'O', 'G']\n",
      "['↑', '↑', 'O', '↑', '↑', '↓', '↑', 'O', '↑']\n",
      "['↓', '↑', 'O', '→', '→', '↓', '↑', 'O', '↑']\n",
      "['↓', '↓', 'O', '→', '→', '→', '→', '→', '↑']\n",
      "['→', '→', '→', '→', '↑', 'O', '↑', '↑', '↑']\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑']\n",
      "Path is: 14\n",
      "['.', '.', '.', '.', '.', '.', '.', 'O', 'G']\n",
      "['.', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['↓', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['↓', '.', 'O', '.', '→', '→', '→', '→', '↑']\n",
      "['→', '→', '→', '→', '↑', 'O', '.', '.', '.']\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "--------------------\n",
      "----------[5]----------\n",
      "['↓', '→', '→', '↓', '↓', '↓', '↓', 'O', 'G']\n",
      "['↓', '↓', 'O', '→', '↓', '↓', '↓', 'O', '↑']\n",
      "['↓', '↓', 'O', '→', '↓', '↓', '↓', 'O', '↑']\n",
      "['→', '↓', 'O', '→', '→', '→', '→', '→', '↑']\n",
      "['→', '→', '→', '→', '↑', 'O', '↑', '↑', '←']\n",
      "['→', '↑', '→', '↑', '↑', '←', '↑', '↑', '←']\n",
      "Path is: 14\n",
      "['.', '.', '.', '.', '.', '.', '.', 'O', 'G']\n",
      "['.', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['↓', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['→', '↓', 'O', '.', '→', '→', '→', '→', '↑']\n",
      "['.', '→', '→', '→', '↑', 'O', '.', '.', '.']\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "--------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:41<00:00,  4.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------[50]----------\n",
      "['→', '→', '→', '↓', '↓', '←', '↓', 'O', 'G']\n",
      "['→', '↓', 'O', '↓', '↓', '←', '←', 'O', '↑']\n",
      "['↓', '↓', 'O', '↓', '→', '↓', '←', 'O', '↑']\n",
      "['→', '↓', 'O', '→', '→', '→', '→', '→', '↑']\n",
      "['→', '→', '→', '→', '↑', 'O', '↑', '↑', '↑']\n",
      "['→', '↑', '↑', '↑', '↑', '→', '↑', '↑', '↑']\n",
      "Path is: 14\n",
      "['.', '.', '.', '.', '.', '.', '.', 'O', 'G']\n",
      "['.', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['↓', '.', 'O', '.', '.', '.', '.', 'O', '↑']\n",
      "['→', '↓', 'O', '.', '→', '→', '→', '→', '↑']\n",
      "['.', '→', '→', '→', '↑', 'O', '.', '.', '.']\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "--------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_8_2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Time-based model for planning in Dyna-Q+\n",
    "class TimeModel:\n",
    "    # @maze: the maze instance. Indeed it's not very reasonable to give access to maze to the model.\n",
    "    # @timeWeight: also called kappa, the weight for elapsed time in sampling reward, it need to be small\n",
    "    # @rand: an instance of np.random.RandomState for sampling\n",
    "    def __init__(self, maze:Maze, time_weight=1e-4, rand=np.random):\n",
    "        self.rand = rand\n",
    "        self.model = dict()\n",
    "\n",
    "        # track the total time\n",
    "        self.time = 0\n",
    "\n",
    "        self.time_weight = time_weight\n",
    "        self.maze = maze\n",
    "\n",
    "    # feed the model with previous experience\n",
    "    def feed(self, state, action, next_state, reward):\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        self.time += 1\n",
    "        if tuple(state) not in self.model.keys():\n",
    "            self.model[tuple(state)] = dict()\n",
    "            # Actions that had never been tried before from a state were allowed to be considered in the planning step\n",
    "            for action_ in self.maze.actions:\n",
    "                if action_ != action:\n",
    "                    # Such actions would lead back to the same state with a reward of zero\n",
    "                    # Notice that the minimum time stamp is 1 instead of 0\n",
    "                    self.model[tuple(state)][action_] = [list(state), 0, 1]\n",
    "        self.model[tuple(state)][action] = [list(next_state), reward, self.time]\n",
    "\n",
    "\n",
    "    # randomly sample from previous experience\n",
    "    def sample(self):\n",
    "        state_index = self.rand.choice(range(len(self.model.keys())))\n",
    "        state = list(self.model)[state_index]\n",
    "        action_index = self.rand.choice(range(len(self.model[state].keys())))\n",
    "        action = list(self.model[state])[action_index]\n",
    "        next_state, reward, time = self.model[state][action]\n",
    "\n",
    "        # adjust reward with elapsed time since last vist\n",
    "        reward += self.time_weight * np.sqrt(self.time - time)\n",
    "\n",
    "\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "\n",
    "        return list(state), action, list(next_state), reward\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wrapper function for changing maze\n",
    "# @maze: a maze instance\n",
    "# @dynaParams: several parameters for dyna algorithms\n",
    "def changing_maze(maze:Maze, dyna_params:DynaParams):\n",
    "    # set up max steps\n",
    "    max_steps = maze.max_steps\n",
    "\n",
    "    # track the cumulative rewards\n",
    "    rewards = np.zeros((dyna_params.runs, 2, max_steps))\n",
    "\n",
    "    for run in tqdm(range(dyna_params.runs)):\n",
    "        # set up models\n",
    "        models = [TrivialModel(), TimeModel(maze, time_weight=dyna_params.time_weight)]\n",
    "\n",
    "        # initialize state action values\n",
    "        q_values = [np.zeros(maze.q_size), np.zeros(maze.q_size)]\n",
    "\n",
    "        for i in range(len(dyna_params.methods)):\n",
    "            # print('run:', run, dyna_params.methods[i])\n",
    "\n",
    "            # set old obstacles for the maze\n",
    "            maze.obstacles = maze.old_obstacles\n",
    "\n",
    "\n",
    "            steps = 0\n",
    "            last_steps = steps\n",
    "            while steps < max_steps:\n",
    "                # play for an episode\n",
    "                steps += dyna_q(q_values[i], models[i], maze, dyna_params)\n",
    "                # update cumulative rewards\n",
    "                rewards[run, i, last_steps:steps] = rewards[run, i, last_steps]\n",
    "                rewards[run, i, min(steps, max_steps - 1)] = rewards[run, i, last_steps] + 1\n",
    "                last_steps = steps\n",
    "                if steps > maze.obstacle_switch_time:\n",
    "                    # change the obstacles\n",
    "                    maze.obstacles = maze.new_obstacles\n",
    "    print(\"-\" * 10, end='')\n",
    "    print(f\"[{dyna_params.methods[0]}][{run + 1}/{dyna_params.runs}]\", end='')\n",
    "    print(\"-\" * 10)\n",
    "    print_maze(q_values[0], maze)\n",
    "    print(\"-\" * 10, end='')\n",
    "    print(\"-\" * 10)\n",
    "    print(\"-\" * 10, end='')\n",
    "    print(f\"[{dyna_params.methods[1]}][{run + 1}/{dyna_params.runs}]\", end='')\n",
    "    print(\"-\" * 10)\n",
    "    print_maze(q_values[1], maze)\n",
    "    print(\"-\" * 10, end='')\n",
    "    print(\"-\" * 10)\n",
    "        \n",
    "    # averaging over runs\n",
    "    rewards = rewards.mean(axis=0)\n",
    "\n",
    "    return rewards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Figure 8.4, BlockingMaze\n",
    "def figure_8_4():\n",
    "    # set up a blocking maze instance\n",
    "    blocking_maze = Maze()\n",
    "    blocking_maze.START_STATE = [5, 3]\n",
    "    blocking_maze.GOAL_STATES = [[0, 8]]\n",
    "    blocking_maze.old_obstacles = [[3, i] for i in range(0, 8)]\n",
    "\n",
    "    # new obstalces will block the optimal path\n",
    "    blocking_maze.new_obstacles = [[3, i] for i in range(1, 9)]\n",
    "\n",
    "    # step limit\n",
    "    blocking_maze.max_steps = 3000\n",
    "\n",
    "    # obstacles will change after 1000 steps\n",
    "    # the exact step for changing will be different\n",
    "    # However given that 1000 steps is long enough for both algorithms to converge,\n",
    "    # the difference is guaranteed to be very small\n",
    "    blocking_maze.obstacle_switch_time = 1000\n",
    "\n",
    "    # set up parameters\n",
    "    dyna_params = DynaParams()\n",
    "    dyna_params.alpha = 1.0\n",
    "    dyna_params.planning_steps = 10\n",
    "    dyna_params.runs = 20\n",
    "\n",
    "    # kappa must be small, as the reward for getting the goal is only 1\n",
    "    dyna_params.time_weight = 1e-4\n",
    "\n",
    "    # play\n",
    "    rewards = changing_maze(blocking_maze, dyna_params)\n",
    "\n",
    "    for i in range(len(dyna_params.methods)):\n",
    "        plt.plot(rewards[i, :], label=dyna_params.methods[i])\n",
    "    plt.xlabel('time steps')\n",
    "    plt.ylabel('cumulative reward')\n",
    "    plt.legend()\n",
    "# \n",
    "    # plt.savefig('../images/figure_8_4.png')\n",
    "    # plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [01:09<00:00,  3.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------[Dyna-Q][20/20]----------\n",
      "['→', '→', '→', '→', '→', '→', '→', '→', 'G']\n",
      "['↑', '↑', '←', '↑', '↑', '↑', '→', '→', '↑']\n",
      "['↑', '↑', '→', '↑', '↑', '↑', '←', '↑', '↑']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
      "['↑', '←', '←', '←', '←', '←', '←', '←', '←']\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑']\n",
      "Path is: 16\n",
      "['→', '→', '→', '→', '→', '→', '→', '→', 'G']\n",
      "['↑', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "['↑', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
      "['↑', '←', '←', '←', '.', '.', '.', '.', '.']\n",
      "['.', '.', '.', '↑', '.', '.', '.', '.', '.']\n",
      "--------------------\n",
      "----------[Dyna-Q+][20/20]----------\n",
      "['→', '↓', '↑', '→', '→', '→', '→', '→', 'G']\n",
      "['→', '↓', '↓', '→', '→', '→', '→', '↑', '↓']\n",
      "['→', '→', '→', '→', '→', '→', '↑', '↑', '←']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
      "['↑', '←', '←', '←', '←', '←', '←', '←', '←']\n",
      "['↑', '↑', '↑', '←', '↑', '↑', '←', '←', '←']\n",
      "Path is: 16\n",
      "['.', '.', '.', '.', '.', '.', '.', '→', 'G']\n",
      "['.', '.', '.', '.', '.', '.', '→', '↑', '.']\n",
      "['→', '→', '→', '→', '→', '→', '↑', '.', '.']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
      "['↑', '←', '←', '.', '.', '.', '.', '.', '.']\n",
      "['.', '.', '↑', '←', '.', '.', '.', '.', '.']\n",
      "--------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_8_4()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Figure 8.5, ShortcutMaze\n",
    "def figure_8_5():\n",
    "    # set up a shortcut maze instance\n",
    "    shortcut_maze = Maze()\n",
    "    shortcut_maze.START_STATE = [5, 3]\n",
    "    shortcut_maze.GOAL_STATES = [[0, 8]]\n",
    "    shortcut_maze.old_obstacles = [[3, i] for i in range(1, 9)]\n",
    "\n",
    "    # new obstacles will have a shorter path\n",
    "    shortcut_maze.new_obstacles = [[3, i] for i in range(1, 8)]\n",
    "\n",
    "    # step limit\n",
    "    shortcut_maze.max_steps = 6000\n",
    "\n",
    "    # obstacles will change after 3000 steps\n",
    "    # the exact step for changing will be different\n",
    "    # However given that 3000 steps is long enough for both algorithms to converge,\n",
    "    # the difference is guaranteed to be very small\n",
    "    shortcut_maze.obstacle_switch_time = 3000\n",
    "\n",
    "    # set up parameters\n",
    "    dyna_params = DynaParams()\n",
    "\n",
    "    # 50-step planning\n",
    "    dyna_params.planning_steps = 50\n",
    "    dyna_params.runs = 5\n",
    "    dyna_params.time_weight = 1e-3\n",
    "    dyna_params.alpha = 1.0\n",
    "\n",
    "    # play\n",
    "    rewards = changing_maze(shortcut_maze, dyna_params)\n",
    "\n",
    "    for i in range(len(dyna_params.methods)):\n",
    "        plt.plot( rewards[i, :], label=dyna_params.methods[i])\n",
    "    plt.xlabel('time steps')\n",
    "    plt.ylabel('cumulative reward')\n",
    "    plt.legend()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5/5 [02:32<00:00, 30.42s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------[Dyna-Q][5/5]----------\n",
      "['→', '→', '→', '→', '→', '→', '→', '→', 'G']\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑', '←']\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '↑']\n",
      "['↑', '←', '←', '←', '←', '←', '←', '←', '←']\n",
      "['↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑', '↑']\n",
      "Path is: 16\n",
      "['→', '→', '→', '→', '→', '→', '→', '→', 'G']\n",
      "['↑', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "['↑', '.', '.', '.', '.', '.', '.', '.', '.']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '.']\n",
      "['↑', '←', '←', '←', '.', '.', '.', '.', '.']\n",
      "['.', '.', '.', '↑', '.', '.', '.', '.', '.']\n",
      "--------------------\n",
      "----------[Dyna-Q+][5/5]----------\n",
      "['→', '→', '→', '↓', '→', '→', '→', '→', 'G']\n",
      "['→', '↑', '↑', '→', '→', '→', '→', '→', '↑']\n",
      "['→', '→', '→', '→', '↑', '→', '↑', '→', '↑']\n",
      "['↑', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '↑']\n",
      "['→', '→', '↑', '→', '→', '→', '→', '→', '↑']\n",
      "['→', '↑', '→', '→', '→', '→', '→', '↑', '↓']\n",
      "Path is: 10\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', 'G']\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', '↑']\n",
      "['.', '.', '.', '.', '.', '.', '.', '.', '↑']\n",
      "['.', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '↑']\n",
      "['.', '.', '.', '.', '.', '.', '.', '→', '↑']\n",
      "['.', '.', '.', '→', '→', '→', '→', '↑', '.']\n",
      "--------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByQ0lEQVR4nO3dd3iN9/sH8Hf2HkKmTHsmdsTesfesXaOIvX2rraKNaqlRu4hqUZRqFTUTK4JYsVeIkaEiS2Sd8/n9cX6e45g5cU5OcvJ+XZfrOp/7Wfd5qsnteT7DQAghQERERKSnDHWdABEREZE2sdghIiIivcZih4iIiPQaix0iIiLSayx2iIiISK+x2CEiIiK9xmKHiIiI9JqxrhMoCORyOR4/fgwbGxsYGBjoOh0iIiLKBSEEUlNT4ebmBkPDdz+/YbED4PHjx/Dw8NB1GkRERJQHDx48gLu7+zu3s9gBYGNjA0Bxs2xtbXWcDREREeVGSkoKPDw8pN/j78JiB5BeXdna2rLYISIiKmQ+1AWFHZSJiIhIr7HYISIiIr3GYoeIiIj0Gvvs5JJcLkdWVpau06A8MDExgZGRka7TICIiHWGxkwtZWVmIjo6GXC7XdSqUR/b29nBxceE8SkRERRCLnQ8QQiA2NhZGRkbw8PB476RFVPAIIZCeno6EhAQAgKurq44zIiKi/MZi5wNycnKQnp4ONzc3WFpa6jodygMLCwsAQEJCApycnPhKi4ioiOFjig+QyWQAAFNTUx1nQh/jZaGanZ2t40yIiCi/sdjJJfb1KNz434+IqOhisUNERER6jcUOERER6TUWO0RERKTXWOzoqUGDBsHAwAAGBgYwMTGBs7MzWrZsiXXr1hWo+YJOnjyJtm3bolixYjA3N0fVqlWxcOFCqWM4EREVck/vAKlxgCxHZymw2NFjrVu3RmxsLO7du4e9e/eiadOmGDduHNq3b4+cHN39pXtp586daNy4Mdzd3XHkyBFcv34d48aNw9y5c9G7d28IIXSdIhERfay1LYEF5YEn13WWAufZUZMQAi+ydfPUwcLESK1RRWZmZnBxcQEAlCxZEjVq1EDdunXRvHlzhISE4OTJk0hISMDu3bulY7Kzs1GyZEkEBwdjyJAhaNKkCXx9fWFubo6ff/4ZpqamGDFiBGbNmiUds3DhQqxfvx53796Fg4MDOnTogPnz58Pa2vqduT1//hzDhg1Dx44dsXr1aik+dOhQODs7o2PHjti6dSt69eqlxh0iIqICJWo7kP5U8dmimM7SYLGjphfZMlT68l+dXPvq7EBYmn7cf7JmzZrBz88PO3bswMyZM9GoUSPExsZKMwvv3r0b6enpKkXGhg0bMHHiRERERCA8PByDBg1C/fr10bJlSwCAoaEhlixZAh8fH9y9exejRo3C1KlTsXz58nfmsX//fjx9+hSTJ09+Y1uHDh1Qrlw5bN68mcUOEVFhdesA8McQxWfL4oC1s85S4WusIqhChQq4d+8e6tWrh/Lly2Pjxo3StvXr16NHjx4qT2V8fX3x1VdfoWzZshgwYABq1aqFQ4cOSdvHjx+Ppk2bwtvbG82aNcPcuXOxdevW9+Zw8+ZNAEDFihXfmePLfYiIqJDZ/wXwW3dle/RZwEh3z1f4ZEdNFiZGuDo7UGfX1gQhhPQ6bOjQoVi9ejWmTp2K+Ph47N27F4cPH1bZ39fXV6Xt6uoqrTUFAAcPHkRwcDCuX7+OlJQU5OTkICMjA+np6bC0tFQpnPr164eVK1eq5PIunLWaiKiQEQLY0AG4d0zRNjBUFDqWDjpNi8WOmgwMDD76VZKuXbt2DT4+PgCAAQMGYPr06QgPD8fJkyfh4+ODhg0bquxvYmKi0jYwMJBGdN27dw/t27fHyJEj8c0338DBwQHHjx/HkCFDkJWVBUtLS1y4cEE61tbWFgBQtmxZKZd69eq9Ncdq1app6isTEZG2CQGsbwvEnFS07TyAEccBC3udpgWw2ClyDh8+jKioKEyYMAEAULx4cXTu3Bnr169HeHg4Bg8erNb5IiMjIZfLsWDBAmlF+NdfYZUpU+aN4wIDA+Hg4IAFCxa8Uez89ddfuHXrFhYtWqRWLkREpCNCANsGKgsdx4pA0Cnd5vQKFjt6LDMzE3FxcZDJZIiPj8e+ffsQHByM9u3bY8CAAdJ+Q4cORfv27SGTyTBw4EC1rlGmTBlkZ2dj6dKl6NChA06cOKHymupdrKyssGrVKvTu3RvDhw/H6NGjYWtri0OHDmHKlCkYNmwY2rZtq/Z3JiIiHfi1K3Dn/7tA+DQC+v+p03Rexw7Kemzfvn1wdXWFt7c3WrdujSNHjmDJkiXYtWsXjIyU/X9atGgBV1dXBAYGws3NTa1r+Pn5YeHChfjuu+9QpUoV/PbbbwgODs7Vsd27d8eRI0cQExODhg0bwsfHB0OHDsX06dNVhqMTEVEBFjpPWei41QD67wIMNdPHVFMMBGduQ0pKCuzs7JCcnCz1KXkpIyMD0dHR8PHxgbm5uY4y1K60tDSULFkS69evR9euXXWWR0ZGBjp16oQHDx4gLCwMjo6OGj23vv93JCLKd+d+Af4ao/hs5QhMvgWoMR/cx3rf7+9X8clOESaXy5GQkIA5c+bA3t4eHTt21Gk+5ubm2LVrFwYMGICjR4/qNBciIvqAWweVhY69JzDuUr4WOupgn50iLCYmBj4+PnB3d0dISAiMjXX/18Hc3BzTp0/XdRpERPQ+N/8FNvVUtj87Cpha6i6fD9Dpk50VK1bA19cXtra2sLW1RUBAAPbu3Sttb9KkibSY5cs/I0aMUDlHTEwM2rVrB0tLSzg5OWHKlCkFYt2nwsDb2xtCCDx48ADNmzfXdTpERFQY3D+pWuiMv6zTpSByQ6f/lHd3d8e8efNQtmxZCCGwYcMGdOrUCefPn0flypUBAMOGDcPs2bOlYywtlZWjTCZDu3bt4OLigpMnTyI2NhYDBgyAiYkJvv3223z/PkRERHrt0jZgx1Ble9wlwN5Dd/nkkk6LnQ4dOqi0v/nmG6xYsQKnTp2Sih1LS0tpMcvX7d+/H1evXsXBgwfh7OyMatWqYc6cOZg2bRpmzZr1zhl4MzMzkZmZKbVTUlI09I2IiIj01IklwIEvlO2gM0AxL93lo4YC00FZJpNhy5YteP78OQICAqT4b7/9hhIlSqBKlSqYMWMG0tPTpW3h4eGoWrUqnJ2Vi4sFBgYiJSUFV65ceee1goODYWdnJ/3x8Cj4VSkREZHOHP9RtdAZeRJwLKe7fNSk8x6pUVFRCAgIQEZGBqytrbFz505UqlQJAPDJJ5/Ay8sLbm5uuHTpEqZNm4YbN25gx44dAIC4uDiVQgeA1I6Li3vnNWfMmIGJEydK7ZSUFBY8REREbxP6HRD6SteQafcKfB+d1+m82ClfvjwuXLiA5ORkbN++HQMHDkRYWBgqVaqE4cOHS/tVrVoVrq6uaN68Oe7cuYPSpUvn+ZpmZmYwMzPTRPpERET66+9xQGSI4rO9FzD2AmBYYF4K5ZrOMzY1NUWZMmVQs2ZNBAcHw8/PD4sXL37rvv7+/gCA27dvAwBcXFwQHx+vss/L9rv6+RAREVEuHPhKWejYllSsXl4ICx2gABQ7r5PL5Sqdh1/1cvVsV1dXAEBAQACioqKQkJAg7XPgwAHY2tpKr8KKqkGDBknD9U1MTODs7IyWLVti3bp10orlBcHJkyfRtm1bFCtWDObm5qhatSoWLlwImUym69SIiIquyBDgxCLFZ9uSwLiLgPHbB/0UBjotdmbMmIGjR4/i3r17iIqKwowZMxAaGoq+ffvizp07mDNnDiIjI3Hv3j389ddfGDBgABo1agRfX18AQKtWrVCpUiX0798fFy9exL///ouZM2ciKCiIr6kAtG7dGrGxsbh37x727t2Lpk2bYty4cWjfvn2BmIto586daNy4Mdzd3XHkyBFcv34d48aNw9y5c9G7d2+8ayWTe/fuwaCAztJJRFToXduteH310ugzgJGJ7vLRBKFDn376qfDy8hKmpqbC0dFRNG/eXOzfv18IIURMTIxo1KiRcHBwEGZmZqJMmTJiypQpIjk5WeUc9+7dE23atBEWFhaiRIkSYtKkSSI7O1utPJKTkwWAN84thBAvXrwQV69eFS9evMj7F9WBgQMHik6dOr0RP3TokAAg1qxZIwYPHizatWunsj0rK0s4OjqKn3/+WQghROPGjcWYMWPElClTRLFixYSzs7P46quvVI5ZsGCBqFKlirC0tBTu7u5i5MiRIjU19b35paWlieLFi4uuXbu+se2vv/4SAMSWLVveemx0dLRQ969uYf3vSESUr67tFuIrW+Wf1ARdZ/Re7/v9/SqddlBeu3btO7d5eHggLCzsg+fw8vLCnj17NJnW+wkBZKd/eD9tMLH86HVHmjVrBj8/P+zYsQMzZ85Eo0aNEBsbK70a3L17N9LT09GrVy/pmA0bNmDixImIiIhAeHg4Bg0ahPr166Nly5YAAENDQyxZsgQ+Pj64e/cuRo0ahalTp2L58uXvzGP//v14+vQpJk+e/Ma2Dh06oFy5cti8ebNKHkREpEURq4C9UxWfDYyASdcBa80tyKxLOh+NVehkpwPfuunm2v97DJhaffRpKlSogEuXLqFevXooX748Nm7ciKlTFX/B169fjx49esDa2lra39fXF1999RUAoGzZsvjpp59w6NAhqdgZP368tK+3tzfmzp2LESNGvLfYuXnzJgCgYsWK78zx5T5ERKRlV/9SFjowULy6snbSaUqaVOA6KJP2CSGkPi9Dhw7F+vXrAShGsu3duxeffvqpyv4v+0i95OrqqtIp/ODBg2jevDlKliwJGxsb9O/fH0+fPpUmgLS2tpb+vL62mXhHvxwAKjNgV65cWTrHy9m1Xz1vmzZt1L0NREQEAI/PA1v7K9vjLgLF8z69S0HEJzvqMrFUPGHR1bU14Nq1a/Dx8QEADBgwANOnT0d4eDhOnjwJHx8fNGzYUPWyJqod0wwMDKQRXffu3UP79u0xcuRIfPPNN3BwcMDx48cxZMgQZGVlwdLSUhpFBwC2trYAFE+IXuZSr169t+ZYrVo1qb1nzx5kZ2cDAB49eoQmTZqonNfCwiJvN4OIqChLegCsbqJsjzlXaJaAUAeLHXUZGGjkVZKuHD58GFFRUZgwYQIAoHjx4ujcuTPWr1+P8PBwDB48WK3zRUZGQi6XY8GCBTD8//kXtm7dqrJPmTJl3jguMDAQDg4OWLBgwRvFzl9//YVbt25h0aJFUszLS/k/n7Gx8TvPS0REuXR9D7Clj7Ld9w+9e6LzEosdPZaZmYm4uDjIZDLEx8dj3759CA4ORvv27TFgwABpv6FDh6J9+/aQyWQYOHCgWtcoU6YMsrOzsXTpUnTo0AEnTpzAypUrP3iclZUVVq1ahd69e2P48OEYPXo0bG1tcejQIUyZMgXDhg1D27Zt1f7ORESUC9FHVQuddguAsi10l4+WsdjRY/v27YOrqyuMjY1RrFgx+Pn5YcmSJRg4cKD0FAYAWrRoAVdXV1SuXBlubup1vvbz88PChQvx3XffYcaMGWjUqBGCg4NViql36d69O44cOYJvvvkGDRs2lFaf/+6776QO00REpGHRx4ANHZTtEccBl6q6yycfGIj39RAtIlJSUmBnZ4fk5GSpT8lLGRkZiI6Oho+PD8zNzXWUoXalpaWhZMmSWL9+Pbp27aqzPDIyMtCpUyc8ePAAYWFhcHTU3JDHovDfkYjog+KvACte6Tow5Q5gVUJ3+Xyk9/3+fhVHYxVhcrkcCQkJmDNnDuzt7dGxY0ed5mNubo5du3ZhwIABOHr0qE5zISLSO9f3qBY6QWcKdaGjDr7GKsJiYmLg4+MDd3d3hISESB1/dcnc3BzTp0/XdRpERPrl5n7VPjqf7gccy+kun3ym+99upDPe3t7vneeGiIj0wIMzwKYeyvaIE4BLFd3lowMsdoiIiPRV8iNg7SujrEaGA86VdJePjrDPTi7xCUjhxv9+RFTkPLkJ/PhKYTPscJEsdAAWOx9kZGQEAMjKytJxJvQxXi5d8fps0EREeunKn8Cy2sp2vx1AyZo6S0fX+BrrA4yNjWFpaYknT57AxMREZX4aKviEEEhPT0dCQgLs7e2l4pWISG89OANse2WC2H5/AGWa6y6fAoDFzgcYGBjA1dUV0dHRuH//vq7ToTyyt7eHi4uLrtMgItKumAhgXStle8JVwK6k7vIpIFjs5IKpqSnKli3LV1mFlImJCZ/oEJH+u3UQ+K2bsj30MAud/8diJ5cMDQ058y4RERVMIe2Be8eU7U+2Ae5Ft4/O61jsEBERFVZCAKsaAXGXFG0DI2DIARY6r2GxQ0REVBjJ5cCiqkDKQ0W7Qnug92+6zamA4tAiIiKiwkYuAxZVURY6Vbqx0HkPFjtERESFyctXVymPFO0aA4Du63SbUwHHYoeIiKgw2dABiL+s+FytH9BxqW7zKQTYZ4eIiKgwkMuBkLZATLiiXTYQ6LxMtzkVEnyyQ0REVBjsm6YsdBwrAn236jafQoTFDhERUUF3+Q/g9GrF5/LtgKBTus2nkGGxQ0REVJDdPwls/1Tx2bYk0GujbvMphFjsEBERFVSPzwPr2yjbo8IBQy5/oy4WO0RERAXRo0hgdRNle3wUYG6ns3QKMxY7REREBU1kCLCmmbI9+ixg76mzdAo7Dj0nIiIqKFLjgS19FE91Xhr0D1CirO5y0gMsdoiIiAqClMfAworKtqk1MOww4FhedznpCRY7REREupaRolroNJgINPsCMGRvE01gsUNERKRLshxgRX1lu/s6xcKepDEsGYmIiHRpxzAgOUbxue0PLHS0gE92iIiIdCHrObCiHvDsnqJdbwxQZ5hOU9JXOn2ys2LFCvj6+sLW1ha2trYICAjA3r17pe0ZGRkICgpC8eLFYW1tjW7duiE+Pl7lHDExMWjXrh0sLS3h5OSEKVOmICcnJ7+/ChERUe7J5cDKBspCx38k0HKOTlPSZzotdtzd3TFv3jxERkbi7NmzaNasGTp16oQrV64AACZMmIC///4b27ZtQ1hYGB4/foyuXbtKx8tkMrRr1w5ZWVk4efIkNmzYgJCQEHz55Ze6+kpERETvJwTwnReQeFfRbjkbaDMPMDDQbV56zEAIIXSdxKscHBzw/fffo3v37nB0dMSmTZvQvXt3AMD169dRsWJFhIeHo27duti7dy/at2+Px48fw9nZGQCwcuVKTJs2DU+ePIGpqelbr5GZmYnMzEypnZKSAg8PDyQnJ8PW1lb7X5KIiIomuQz4YyhwZYeiXXcU0DpYtzkVYikpKbCzs/vg7+8C00FZJpNhy5YteP78OQICAhAZGYns7Gy0aNFC2qdChQrw9PREeLhiifvw8HBUrVpVKnQAIDAwECkpKdLTobcJDg6GnZ2d9MfDw0N7X4yIiAhQvLr6rbuy0CnVhIVOPtF5sRMVFQVra2uYmZlhxIgR2LlzJypVqoS4uDiYmprC3t5eZX9nZ2fExcUBAOLi4lQKnZfbX257lxkzZiA5OVn68+DBA81+KSIiolelPAbmFAfuHFa0vRoA/XboNqciROejscqXL48LFy4gOTkZ27dvx8CBAxEWFqbVa5qZmcHMzEyr1yAiIgIApCeqThhYYyDQYTH76OQjnRc7pqamKFOmDACgZs2aOHPmDBYvXoxevXohKysLSUlJKk934uPj4eLiAgBwcXHB6dOnVc73crTWy32IiIh0JicLWFxN2e64FKgxQGfpFFU6f431OrlcjszMTNSsWRMmJiY4dOiQtO3GjRuIiYlBQEAAACAgIABRUVFISEiQ9jlw4ABsbW1RqVKlfM+diIhIIgTwUy0gM1nRbrewSBY6/16Jw+Hr8UjNyNZZDjp9sjNjxgy0adMGnp6eSE1NxaZNmxAaGop///0XdnZ2GDJkCCZOnAgHBwfY2tpizJgxCAgIQN26dQEArVq1QqVKldC/f3/Mnz8fcXFxmDlzJoKCgviaioiIdCfrOfCtm7JdfzxQe4jO0tGl6X9cwrP0bByY0Ag25iY6yUGnxU5CQgIGDBiA2NhY2NnZwdfXF//++y9atmwJAPjxxx9haGiIbt26ITMzE4GBgVi+fLl0vJGREXbv3o2RI0ciICAAVlZWGDhwIGbPnq2rr0REREWdEMAPr6xUXjYQaPm17vLRESEElofewbN0xRMdOwvdFDpAAZxnRxdyO06fiIjovXKygGV1gGfRinaNAYp+OkXM46QXqDfvsNT2Lm6Jw5OawNBQs52yc/v7W+cdlImIiPTCi2fAqkZA0v8v6unbu0gWOrP/vop1J6Kldh1vB6zsX1PjhY46WOwQERF9rMxUYH4pQMgV7cpdgc4rdJtTPktIyUCX5SfxKOmFFFvZryZaV9H96GgWO0RERB9DlgMEuyvbrb4B6o3WXT75TAiB4L3XsfroXSnmXswChyY1hpmxkQ4zU2KxQ0RElFc5mcCqxsp2u4VFatTVtdgUDAk5g8fJGVLs++6+6FGrYC3DxGKHiIgoL2Q5wJLqQMojRbvemCJV6Kw9Ho05u69K7YZlS2DNgFowNykYT3NexWKHiIhIXbIcYGkNZaFTvR/Qaq5uc8oncckZGLLhDK48TpFiq/vXRKvKuu+b8y4sdoiIiNQhBBDSFki6r2jXHKRY60rPCSHw0+HbWHDgphTz87DHmv414WRrrsPMPozFDhERkTq2fAI8iFB8rtihSBQ61+NS0HX5SaRnyaTY99190a2Gu06HlOcWix0iIqLcOrEYuLFH8bl4GaDnRt3mo2UyucCnIWcQdvOJFCvIfXPehcUOERHRhwgB7J8JhP+kaBfzBkaGAwYF/6lGXp24/R/6/hyhEls3qBaaVXDWUUZ5x2KHiIjofYQA1rYEHp5RtE2sgBHHAWNT3ealJUIIDN1wFoeuJ0ix3rU9MK+brw6z+jgsdoiIiN7nwJfKQsfeC/gsDDCz0W1OWvIgMR09V4Uj9pV5c/4d3wjlXQr392WxQ0RE9C6/dgduH1B8Lt0c6PeHXr66ettIq2YVnLB2YC0Y6MH3ZbFDRET0Nn+PUxY6JWsC/XfoNh8tuR6Xgm7LT+L5KyOtlvSpjo5+bjrMSrNY7BAREb0uYjUQGaL47FQJGHZYp+logxACX/99FSEn70kxP3c7bPi0Duwt9as/EosdIiKiV51eA+ydovjsUBr47Khu89GC/9Iy0XrRMfyXlglA8Wbux57V0Ll6SR1nph0sdoiIiADFqKvdE4DI9Yq2hYOi0DEy0W1eGiSEwP92Xsbm0zFSrJqHPX7/rG6BWaFcG1jsEBERAcDmPsDNvYrPBobA+EuAmbVuc9KghNQMdFh6HPEpmVJsZruKGNqwlA6zyh8sdoiIqGiTy4Adw5SFjlsN4NN9gLGZbvPSkBdZMqw+ehc/HlSOtLKzMMGJ6c1gbVY0yoCi8S2JiIjeRi4DVjcG4qIUbc8ARaGjJx4lvUDnZSfwJFX5NEffRlrlBosdIiIqmrLSgVWNgKe3FG2/T4DOy3Wbk4bI5QLLjqjOm1Pbuxh+HlAbdpb60wcpt1jsEBFR0ZOZCvxUB0h9rGiXbwd0WaHbnDTk3n/P0eSHUJXYwp5+6FrDXTcJFQAsdoiIqGjJyVQtdAJGA4Hf6DYnDZDJFbMgv9o3p4S1GfaMawAnG3MdZqZ7LHaIiKjokMuA9W2UhU7bH4A6w3SbkwbEp2RgwNrTuBGfKsW+aF8Jg+t5w9Cw8C/38LFY7BARUdGQ/QJYUR9IvKNo1xmuF4XO9siHmLztotQuaW+B7SMD4GpnocOsChYWO0REpP8yU4FFvsCLREW7SjegzXzd5vSR/kvLxLgt53Hi9lMp9m2XqvjE31OHWRVMLHaIiEi/pScCP1YGstMV7cBgIGCUbnP6SH9dfIyxm89L7WKWJtgV1ACexS11mFXBxWKHiIj0V2I0sKSast11DeDbU2fpfKz7T59j1G/ncOVxihSb0aYChjcqBQMD9s15FxY7RESkn+6GAr90UrY7ryjUhc6ao3fxzZ5rUtvRxgz/jm8EByv9WqFcG1jsEBGR/om/qlro9P8TKN1UZ+l8jPiUDPRZcwp3nzyXYt90qYJP6njyaU4usdghIiL9khQDrAhQtsecA4qX1l0+H2Fl2B3M23tdape0t8DuMQ1QjE9z1MJih4iI9EfWc2BlA2V7wK5CWejEJWeg9+pw3HuaLsXmdKqMfnW9+DQnD1jsEBGRfrj2N/B7P2W721qgVBOdpZMXQggE772O1UfvSrE63g5YM7AW7CyK3ppWmsJih4iICjchgPVtgZiTyljr74Cq3XWXUx5ky+Ro9eNRRP+n7JvzYy8/dKledNe00hQWO0REVHjJsoHVTYH4KEXbwAgYehAoWUO3eanp4NV4DP3lrNR2tTPHnrEN2TdHQwx1efHg4GDUrl0bNjY2cHJyQufOnXHjxg2VfZo0aQIDAwOVPyNGjFDZJyYmBu3atYOlpSWcnJwwZcoU5OTk5OdXISKi/CbLAdY0UxY6DqWBL58WqkJHCIEZOy6pFDpjm5VB+IzmLHQ0SKdPdsLCwhAUFITatWsjJycH//vf/9CqVStcvXoVVlZW0n7Dhg3D7NmzpbalpXKGSJlMhnbt2sHFxQUnT55EbGwsBgwYABMTE3z77bf5+n2IiCifCAHsHA7EXVK0y7UG+mwBClHn3dAbCRi96TzSMhX/OC9uZYpdo+vDvRhnQdY0nRY7+/btU2mHhITAyckJkZGRaNSokRS3tLSEi4vLW8+xf/9+XL16FQcPHoSzszOqVauGOXPmYNq0aZg1axZMTd+sjDMzM5GZmSm1U1JS3tiHiIgKsNB5wOU/FJ8rdgR6/lJoCp2MbBn+tzMKO849kmKf+Hvi646VYWKk0xcueitXxU7Xrl1zfcIdO3bkOZnk5GQAgIODg0r8t99+w6+//goXFxd06NABX3zxhfR0Jzw8HFWrVoWzs7O0f2BgIEaOHIkrV66gevXqb1wnODgYX3/9dZ7zJCIiHTr5ExA2T/HZuyHQY0OhKXSux6Wg75oIPH2eJcU2DfNHvdIldJiV/stVsWNnZyd9FkJg586dsLOzQ61atQAAkZGRSEpKUqsoep1cLsf48eNRv359VKlSRYp/8skn8PLygpubGy5duoRp06bhxo0bUlEVFxenUugAkNpxcXFvvdaMGTMwceJEqZ2SkgIPD488505ERPkkfDmw/3PFZxtXoP9OwLBwPA3ZFBGD/+2MktptqrgguGtV2Fuyb4625arYWb9+vfR52rRp6NmzJ1auXAkjIyMAin4zo0aNgq2tbZ4TCQoKwuXLl3H8+HGV+PDhw6XPVatWhaurK5o3b447d+6gdOm8TRRlZmYGMzOzPOdKREQ68GcQcOFXxWdDY2DcJcCo4M89k5kjw7BfInH05hMptqCHH7rV5JDy/KJ2Obxu3TpMnjxZKnQAwMjICBMnTsS6devylMTo0aOxe/duHDlyBO7u7/+P7+/vDwC4ffs2AMDFxQXx8fEq+7xsv6ufDxERFTKRIcpCBwCmxwDGBf+JyJ/nH6H8zH1SoVPd0x4npjdjoZPP1C52cnJycP369Tfi169fh1wuV+tcQgiMHj0aO3fuxOHDh+Hj4/PBYy5cuAAAcHV1BQAEBAQgKioKCQkJ0j4HDhyAra0tKlWqpFY+RERUAB34Cvh7nOKzvSfweTxgavX+Y3TseWYOeq4Kx/jfL0ix8S3KYsfIeihpb6G7xIootUdjDR48GEOGDMGdO3dQp04dAEBERATmzZuHwYMHq3WuoKAgbNq0Cbt27YKNjY3Ux8bOzg4WFha4c+cONm3ahLZt26J48eK4dOkSJkyYgEaNGsHX1xcA0KpVK1SqVAn9+/fH/PnzERcXh5kzZyIoKIivqoiICrtTK4ETixSfHSsCg/cAJuY6TelD1h6PxpzdV1ViByY0QllnGx1lRAZCCKHOAXK5HD/88AMWL16M2NhYAIqnLOPGjcOkSZNUXm998OLv6D2/fv16DBo0CA8ePEC/fv1w+fJlPH/+HB4eHujSpQtmzpyp0j/o/v37GDlyJEJDQ2FlZYWBAwdi3rx5MDbOXS2XkpICOzs7JCcnf1S/IyIi0qATS4ADXyg+m1gpXl0ZFdyJ/7Ny5Bi7+Tz2XVEOjulR0x3zuvnCyLBwjBYrbHL7+1utYicnJwebNm1CYGAgnJ2dpflpCnuBwGKHiKiAOf4jcHCW4rOhCTDlFmBRTKcpvc9fFx9j7ObzUruUoxV+Hx4ARxu+YdCm3P7+VqtENjY2xogRI3Dt2jUAhb/IISKiAuj8r8pCBwDGXSiwhY4QAgPWncaxW/9JsS/bV8Lg+t7vfHtB+U/t54F16tTB+fPn4eXlpY18iIioKLv5L7Ar6P8bBsDkm4C1k05TepetZx9g6vZLUtvOwgRbPwtAeRf2zSlo1C52Ro0ahUmTJuHhw4eoWbOmyhpWAKSOw0RERGq5vAPY/v8DXQxNgInXAGtH3eb0Fo+TXmDGjiiEvTJvTr+6npjTqQqf5hRQandQNnzLTJUGBgYQQsDAwAAymUxjyeUX9tkhItKxm/uBTT2U7VGnAKeKusvnHV7vm+NkY4ZNw+qijJO1DrMqurTSZwcAoqOjPyoxIiIiFXFRqoXO+CjFfDoFyLPnWfhsYyRO30uUYsMa+mBKYAWYGheO5SqKMrWLHfbVISIijXl8AVjdWNkOOlPgCp3jt/5Dv7URUtvJxgwhg+ugkhvfBBQWeZ6w4OrVq4iJiUFWVpZKvGPHjh+dFBERFQEXtwA7P1O2hxwEHMvpLp/X5MjkGPnbORy4qlySaGgDH8xoW5Hz5hQyahc7d+/eRZcuXRAVFSX11QGUEwQWxj47RESUzy5tUy10hh4C3GvpLp/XhN5IwKD1Z1RiW4bXRd1SxXWUEX0MtV80jhs3Dj4+PkhISIClpSWuXLmCo0ePolatWggNDdVCikREpFfO/AzsGKpsB50uMIVO4vMs9FwVrlLo9K7tgauzA1noFGJqP9kJDw/H4cOHUaJECRgaGsLQ0BANGjRAcHAwxo4di/Pnz3/4JEREVDSdXgPsmaz4bOsOBEUAZrofyZQtk+O7vdfx83HlIBxXO3Os7l8LVd3tdJgZaYLaxY5MJoONjWLCpBIlSuDx48coX748vLy8cOPGDY0nSEREeuJuqLLQAQpMoXM7IQ2D1p/Gw2cvpNiQBj6Y2a4i583RE2oXO1WqVMHFixfh4+MDf39/zJ8/H6ampli9ejVKlSqljRyJiKiwS4oBfumkbE+8ViAKnZ+P3cXcf65J7bqlHLCib00UszLVYVakaWoXOzNnzsTz588BALNnz0b79u3RsGFDFC9eHL///rvGEyQiokIu8S6wpLqyPfYCYOums3QA4EFiOnquCkdscoYUWzeoFppVcNZhVqQtas+g/DaJiYkoVqxYoX3cxxmUiYi0JOUxsPCVmZAH/AWUavzu/fPB8tDbmL9P2e2icTlHrOhXA5ameZ6NhXREazMoHz58GPXq1YO5ubkUc3BwyFuWRESkv+KvAisClO2+f+i00EnNyEbnZSdw58lzKTa/uy961HQvtP9Yp9xRu9jp2LEjcnJyULt2bTRp0gSNGzdG/fr1YWFhoY38iIioMDq3EfhrtLLdfT1QtoXO0jl68wkGrDsttcs722Dj0DpwsjF/z1GkL9Qudp49e4bTp08jLCwMYWFhWLRoEbKyslCrVi00bdoUc+fO1UaeRERUGAgB/N4PuL5bGRu8F/Cqp6N0BCZtu4gd5x5JsQktymFci7I6yYd046P77Fy5cgXff/89fvvtN8jl8kI5gzL77BARaYAQwMYuwN0jirZtSWBUOGCum3lq4lMy0G7JcfyXlinFOAuyftFan52bN28iNDQUoaGhCAsLQ2ZmJho2bIgffvgBTZo0+ZiciYioMPv3f8pCx8UXGHFMZ6lsDL+HL3Zdkdol7S2wb3xD2Jib6Cwn0h21i50KFSrA0dER48aNw/Tp01G1alV27CIiKuqOLwJOLVd8tnIChofqJI2sHDl6rw7HuZgkKTarQyUMqu+jk3yoYFC72Bk7diyOHj2K2bNnY/fu3WjSpAmaNGmCBg0awNLSUhs5EhFRQXZpG3DwK8VnMztgzFnA0Cjf09h5/iEm/H5RaldwscEvn9aBky07IRd1ee6zk5SUhGPHjkkdla9cuYLq1avjxIkTms5R69hnh4goj/79HAj/Sdmechewyt8+MckvstHv5whEPUqWYuOal8WEluXyNQ/Kf1rrs/OSTCZDdnY2MjMzkZGRgczMTK6NRURUlJxeoyx0jMyACVfyvdB5fYJAW3Nj/BlUH6Ucdb8UBRUceXqNFRoaiqtXr6JYsWJo1KgRhg0bhiZNmqBq1arayJGIiAqas+uUi3raewHjLgL52H8zPSsHPVaG48rjFCm2sKcfutZwz7ccqPBQu9iJjY3F8OHD0aRJE1SpUkUbORERUUG273/AqWXK9ugz+VrorD0ejTm7r0ptr+KW2DYigBME0jupXexs27ZNG3kQEVFhcPxHZaFjZKaYR8fYLF8u/SJLhj5rTuHCgyQpNqieN2Z1rJwv16fCyzAvB23cuBH169eHm5sb7t+/DwBYtGgRdu3apdHkiIioADmxBDg4S9n+3yOgeOl8ufTJ2/+hyqx/pULHxdYchyY1ZqFDuaJ2sbNixQpMnDgRbdu2RVJSkjRjsr29PRYtWqTp/IiIqCA48CVw4AvFZ2tn4PM4wCh/JuibseMSPvk5AjK5YvBwtxruODG9GUqzEzLlktrFztKlS7FmzRp8/vnnMDJSzqNQq1YtREVFaTQ5IiIqAELnAScWKz7blgQmXAVMtL/487PnWag19yA2n34gxXaMqocFPf1gZMjJbCn31O6zEx0djerVq78RNzMzw/PnzzWSFBERFQBCAPtnqs6jM/oMYJTnWUtyeVmBTadj8PnOy1KsRUVnrBlQkzP2U56o/TfWx8cHFy5cgJeXl0p83759qFixosYSIyIiHds3A4hYofhs4wqMvQCYaHfE0+2ENHy+MwoR0YlSbGW/GmhdxVWr1yX9pnaxM3HiRAQFBSEjIwNCCJw+fRqbN29GcHAwfv75Z23kSERE+W3/TGWh4+oHDD2s1Sc6crnA7N1XEXLynhQraW+BP4Pqw9Emf0Z7kf5S+2/u0KFDYWFhgZkzZyI9PR2ffPIJ3NzcsHjxYvTu3VsbORIRUX46ux44uVTxuXhZYOghrRY6lx4moe+aCKRm5kix+d190bOWh9auSUWLWn97c3JysGnTJgQGBqJv375IT09HWloanJyctJUfERHlp/O/ArvHK9ujTmmt0BFCYOGBm1h6+LYUq+5pj7UDa8PBylQr16SiSa3RWMbGxhgxYgQyMjIAAJaWlh9V6AQHB6N27dqwsbGBk5MTOnfu/Mb6WhkZGQgKCkLx4sVhbW2Nbt26IT4+XmWfmJgYtGvXTspnypQpyMnJARERqeHoD8CuIGV7arTWCp1b8amoN++wSqGzsl9N7BxVn4UOaZzaQ8/r1KmD8+fPa+TiYWFhCAoKwqlTp3DgwAFkZ2ejVatWKqO6JkyYgL///hvbtm1DWFgYHj9+jK5du0rbZTIZ2rVrh6ysLJw8eRIbNmxASEgIvvzyS43kSERUJFzeARyeo/hsagNMvg1YOmjlUt/8cxUtfzyK2GTFP5wruNjgwpct0bqKi1auR2QghBDqHLB161bMmDEDEyZMQM2aNWFlZaWy3dfXN8/JPHnyBE5OTggLC0OjRo2QnJwMR0dHbNq0Cd27dwcAXL9+HRUrVkR4eDjq1q2LvXv3on379nj8+DGcnZ0BACtXrsS0adPw5MkTmJp++F8IuV0inohILz2MBH5upvhsUQyYeF0ro67iUzLQfulxPEnNlGLBXauiTx1PjV+Liobc/v5W+/nky07IY8eOlWIGBgYQQsDAwECaUTkvkpOTAQAODop/TURGRiI7OxstWrSQ9qlQoQI8PT2lYic8PBxVq1aVCh0ACAwMxMiRI3HlypW3zgmUmZmJzEzl/2wpKSlv7ENEVCTc3A9s6qFsf3ZU44VOtkyOeXuvY+3xaCnWrIIT1gyoxckBKV/kaVJBbZDL5Rg/fjzq168vraYeFxcHU1NT2Nvbq+zr7OyMuLg4aZ9XC52X219ue5vg4GB8/fXXGv4GRESFzMUtwM7PlO1hhwF7zT5leZCYjoHrT+PuE2X3BI60ovymdrHz+mSCmhIUFITLly/j+PHjWjn/q2bMmIGJEydK7ZSUFHh48H88IipCTq8B9kz+/4YBMD4KsNfsz8EF+2+odEDu4OeGb7tUgY15/qypRfSSduf8zqXRo0dj9+7dOHr0KNzd3aW4i4sLsrKykJSUpPJ0Jz4+Hi4uLtI+p0+fVjnfy9FaL/d5nZmZGczMOEkVERVB2S+A33oA944p2naewOjTGl3rKik9C43mH0FKhnJU7E+fVEd7XzeNXYNIHWqPxtIkIQRGjx6NnTt34vDhw/Dx8VHZXrNmTZiYmODQoUNS7MaNG4iJiUFAQAAAICAgAFFRUUhISJD2OXDgAGxtbVGpUqX8+SJERIVBRjKwoLyy0LEtCYwK12ih80v4PVSbfUAqdEraW+DiV61Y6JBO6fTJTlBQEDZt2oRdu3bBxsZG6mNjZ2cHCwsL2NnZYciQIZg4cSIcHBxga2uLMWPGICAgAHXr1gUAtGrVCpUqVUL//v0xf/58xMXFYebMmQgKCuLTGyIiAJBlA4e+Vs6KDAB1hgNt5gMaWljzcdILjPw1EhcfKgaaGBsa4KuOldG/rna6PhCpQ+2h5xq9+Dv+J1u/fj0GDRoEQDGp4KRJk7B582ZkZmYiMDAQy5cvV3lFdf/+fYwcORKhoaGwsrLCwIEDMW/ePBgb566W49BzItJbGcnAj1WAzFdGnbaeB9QdqZHTCyGw5thdfLvnuhSr6VUMm4b5w8zYSCPXIHqX3P7+zlOxk5SUhO3bt+POnTuYMmUKHBwccO7cOTg7O6NkyZIflbgusNghIr2UnqgodLL/fySUR13gky2KuXQ0ICtHjsBFRxH9n3KkVcjg2mhSnksIUf7Q2jw7ly5dQosWLWBnZ4d79+5h2LBhcHBwwI4dOxATE4NffvnloxInIiINSLgGLK+rbLf/Eaj1qcZOv/vSY4zepJxN36eEFXaPaQArswIx7oVIhdodlCdOnIhBgwbh1q1bMDdXTjzVtm1bHD16VKPJERFRHqQ8Vi10uq/XWKGTkS3DZxvPqhQ641uUxZHJTVjoUIGl9t/MM2fOYNWqVW/ES5Ys+c5J/IiIKJ9c2w383lfZ/mQbUK6VRk596WESOi07gZedH0pYm2L3mIZwsdP80hJEmqR2sWNmZvbW5RVu3rwJR0dHjSRFRER5sGs0cH6jst36O40UOjkyOcZuOY89Ucp/0H7i74m5narAkMs9UCGgdrHTsWNHzJ49G1u3bgWgGFEVExODadOmoVu3bhpPkIiIcuH0GtVC59N/Ac+6794/l24npKL/2tPSCuUOVqZY0MMPTSuwEzIVHmr32VmwYAHS0tLg5OSEFy9eoHHjxihTpgxsbGzwzTffaCNHIiJ6n4hVyqUfzO2B6Q80UuhsDL+HFguPSoVO0/KOCJ/RjIUOFTpqP9mxs7PDgQMHcPz4cVy6dAlpaWmoUaOGysrkRESUT3ZPAM6uU3y2LA6MiQTMP24KjdsJqRi7+QKuxiq7LPzYyw9dqru/5yiigkvtYufBgwfw8PBAgwYN0KBBA23kREREuXFisbLQcfEFBv71UXPovMiSYXnobZXFO5uUd0Rw16pwtdPckhJE+U3tYsfb2xsNGjRAv3790L17dxQrppnJqYiISA2HZgPHFig+G5kBw0MBw7zPWHz5UTIGrjuNp8+zpBif5pC+ULvPztmzZ1GnTh3Mnj0brq6u6Ny5M7Zv347MzExt5EdERK+Sy4BfOisLHafKwNQ7eS50ZHKBJYduof3S41Kh07OWO8JnNGOhQ3ojz2tjCSEQGhqKTZs24Y8//oBcLkfXrl2xbt06TeeodVwugogKjTXNgUdnFZ/tPIDxUXlezPNBYjo6/nQcz9KzAQAmRgZY3b8WOyBToaHVtbFed+7cOQwZMgSXLl2CTCb72NPlOxY7RFTgZT0HQtoBj/9/5mKXqsDwo4Ch2g/oAQBrj0djzu6rUrth2RJY3Ls6HKxMNZEtUb7Q2tpYLz18+BCbNm3Cpk2bcPnyZQQEBGDZsmV5PR0REb3LhU3An6+sUu7bG+iyMk9PdG7Gp2Lw+jN4lPRCis1sVxFDG5bSRKZEBZLaxc6qVauwadMmnDhxAhUqVEDfvn2xa9cueHl5aSM/IqKi7egPwOE5yna7hUDtIWqfRgiBxYduYdHBW1KsSklbbB5WFzbmJprIlKjAUrvYmTt3Lvr06YMlS5bAz89PGzkREREA7P8COLlE2Z50E7BxVvs0cckZ+OTnU7j75LkUW9y7GjpVK6mJLIkKPLWLnZiYGBjksTMcERHl0vZPgct/KNvjLuap0Pn52F3M/eea1K7haY91g2rD3pJ9c6joyFWxc+nSJVSpUgWGhoaIiop6776+vr4aSYyIqEjKTAMWVQFePFO03esoJgs0UW9Sv8wcGTouPYEb8alSbHanyujn78XFO6nIyVWxU61aNcTFxcHJyQnVqlWDgYEBXh3E9bJtYGBQKEdjEREVCOmJwIp6ykKnak+g62q1OiLnyORYfewu5u+7IcWszYxxfFpTPs2hIitXxU50dDQcHR2lz0REpGGZacB8H2W76Uyg8RS1TpH4PAs9Vp7EnVf65vSp44ngrlU1lSVRoZSrYufVkVb3799HvXr1YGysemhOTg5OnjzJUVlEROq6d1wxh85Lrb8D6o5Q6xS/n4nB9B1RePnQ3c3OHH+NaYAS1mYaTJSocFK7g3LTpk0RGxsLJyfVGTaTk5PRtGlTvsYiIlLH63PodF4JVOuT68NvxKViwLoIxKcoluwxMTJAcFdfdK/JpR6IXlK72HnZN+d1T58+hZWVlUaSIiIqEk6tAPZNV7YnXgNs3XJ1qBACP+y/gWVH7kixhmVLYHX/WrAwzfuCoET6KNfFTteuXQEoOiMPGjQIZmbKR6MymQyXLl1CvXr1NJ8hEZG+kWUDqxoDCVcUbQNDYNo9wNwuV4c/Sc1E/7URuB6nHGk1p3MV9K/LbgREb5PrYsfOTvE/oRACNjY2sLBQDoM0NTVF3bp1MWzYMM1nSESkT9ITgZUNgZSHirZXfWDAX4DRh38cCyHw48FbWHJIOQuyV3FL/DrEHx4OltrKmKjQy3Wxs379egCAt7c3Jk+ezFdWRETqSk8EltUBnj9RtP1HAm3m5erQ5PRsNF8Yiv/SsqTYt12q4hN/T21kSqRXNLLqeWHHVc+JSOuijwEb2ivbgcFAwKhcHXr4ejw+DTkrtauWtMO2EQEwN2HfHCratLrq+fbt27F161bExMQgKytLZdu5c+fyckoiIv119Hvg8Fxlu/2PQK1PP3hYZo4MXZadxNXYFCn2eduKGNaIK5QTqcNQ3QOWLFmCwYMHw9nZGefPn0edOnVQvHhx3L17F23atNFGjkREhdO9E8AsO9VCZ+jhXBU6YTefoPzMfSqFzu4xDVjoEOWB2k92li9fjtWrV6NPnz4ICQnB1KlTUapUKXz55ZdITEzURo5ERIXPtd3A732V7eJlgWGHPjjiKi0zB7P+uoLtkQ+lWDUPe2z9LACmxmr/+5SIkMdVz18OMbewsEBqqmLoY//+/VG3bl389NNPms2QiKgwEULx2urIN8pY158B3x4fPDTs5hMMXHdaahezNMGPvaqhSXmn9xxFRB+idrHj4uKCxMREeHl5wdPTE6dOnYKfnx+io6PBvs5EVKTdPgRs6gXIsxVtK0dgeChg9/7ZjDOyZRi7+Tz2X42XYp81KoXpbSq8dRJXIlKP2sVOs2bN8Ndff6F69eoYPHgwJkyYgO3bt+Ps2bPSxINEREVKZiqwsQvw8IwyVrImMHA3YPr++W9uJ6Si9aJjyJEr/7G4K6g+/DzstZQsUdGj9tBzuVwOuVwuLQS6ZcsWnDx5EmXLlsVnn30GU1NTrSSqTRx6TkR5lnAdWO6vGhuwCyjV5L2HpWZkY87uq9h6Vtk3Z2gDH/yvbUUYGvJpDlFu5Pb3N+fZAYsdIsqjiFXA3qnKdu2hQNsfgA+8ejpyIwHDNpyVnuZYmhph3aDaqFuquDazJdI7Gp1n59KlS7m+sK+vb673JSIqlLJfAOtaA7EXlLHem4AK7d57WEa2DPP33cC6E9FSrGv1kvimS1Uu3kmkRbkqdqpVqwYDA4MPdkA2MDCATCbL9cWPHj2K77//HpGRkYiNjcXOnTvRuXNnafugQYOwYcMGlWMCAwOxb98+qZ2YmIgxY8bg77//hqGhIbp164bFixfD2to613kQEeXa9X+ALZ8o2zauik7INi7vPSzi7lP0WxuBbJni56iZsSHWDKiFRuUctZgsEQG5LHaio6M/vFMePH/+HH5+fvj000/f2bm5devW0rpcAFRWWweAvn37IjY2FgcOHEB2djYGDx6M4cOHY9OmTVrJmYiKqJwsYFMP4G6oMtZqLlBvzAcPXXTwJhYdVC7e2a2GOz5vVxEOVoWvjyNRYZSrYsfLy0srF2/Tps0HZ102MzODi8vb/8V07do17Nu3D2fOnEGtWrUAAEuXLkXbtm3xww8/wM3NTeM5E1ERdOewYrTVS6bWwLDDgGP59x4Wm/wCA9edxs34NCm2sl9NtK7y/qdARKRZag89/+WXX967fcCAAXlO5m1CQ0Ph5OSEYsWKoVmzZpg7dy6KF1d04gsPD4e9vb1U6ABAixYtYGhoiIiICHTp0uWt58zMzERmZqbUTklJeet+RFTEyWXAriDg4mZlrFxroOdGwPj9T2WWh97G/H03pLa/jwM2DvHnLMhEOqB2sTNu3DiVdnZ2NtLT02FqagpLS0uNFjutW7dG165d4ePjgzt37uB///sf2rRpg/DwcBgZGSEuLg5OTqozixobG8PBwQFxcXHvPG9wcDC+/vprjeVJRHoo8S6wuimQkaRom9sDn+4DnCq+97CElAx0WnYCsckZUmxRr2roXL2k9nIlovdSu9h59uzZG7Fbt25h5MiRmDJlikaSeql3797S56pVq8LX1xelS5dGaGgomjdvnufzzpgxAxMnTpTaKSkp8PDw+KhciUhPyHKAiJXA/s+VsWp9gXYLARPz9x66/0ochm+MlNoBpYpj3aDaHGlFpGNqFztvU7ZsWcybNw/9+vXD9evXNXHKtypVqhRKlCiB27dvo3nz5nBxcUFCQoLKPjk5OUhMTHxnPx9A0Q/o9Y7ORERIvAts6AQkxyhjPX8BKnV672EJqRkYtuEsLj5MlmJftK+EIQ18tJUpEalBI8UOoHh99PjxY02d7q0ePnyIp0+fwtXVFQAQEBCApKQkREZGombNmgCAw4cPQy6Xw9/f/32nIiJSSn4EnPsFCJunjJVrDXRZCVgUe+dhOTI5Vh+7q9I3x6u4JTYNq4uS9hbazJiI1KB2sfPXX3+ptIUQiI2NxU8//YT69eurda60tDTcvn1bakdHR+PChQtwcHCAg4MDvv76a3Tr1g0uLi64c+cOpk6dijJlyiAwMBAAULFiRbRu3RrDhg3DypUrkZ2djdGjR6N3794ciUVEuRN9DNjQXtk2MgU6rwCqdn/vYbfiU9Fu6XFk5cil2Iw2FTC8USku3klUwKi9XIShoepIAgMDAzg6OqJZs2ZYsGCB9NQlN0JDQ9G0adM34gMHDsSKFSvQuXNnnD9/HklJSXBzc0OrVq0wZ84cODs7S/smJiZi9OjRKpMKLlmyRK1JBblcBFERlP0CCPsOOP6jMlatH9BsJmD77p9jQgj8b+dlbD6tfNVVv0xx/NirGpxs3t+nh4g0i2tjqYHFDlERczcU2NIXyFLOf4P+O4HSzd57WOT9Z/hsYyT+S1NMXWFqbIgfe1ZDO9/c/yOPiDRHo2tjERHpBVkOsG8acOZnZaxKNyAwGLBxfudhOTI5Jm27iF0XlP0S65cpjrUDa8PchCOtiAo6tYsdIQS2b9+OI0eOICEhAXK5XGX7jh07NJYcEZHGvDELsg3QbQ1Q/v2zuJ+4/R+GbjiLF9nKdf9W9K2BNlX5NIeosFC72Bk/fjxWrVqFpk2bwtnZmR3xiKhgS4wGfu8PxEcpY1V7AF3XAO/5+SWTC0zdfgl/nHsoxeqXKY7lfWvCzsJEmxkTkYapXexs3LgRO3bsQNu2bbWRDxGRZmQ9Bw7OAk6vVsaMzYFua4GK7d95GABceJCEbitOQiZXdGm0NjPGb0P94edhr718iUhr1C527OzsUKpUKW3kQkSkGVf+BLYNVI0Ffgv4jwAM39/H5vUVyjtXc0NwV1/OgkxUiKld7MyaNQtff/011q1bBwsLTppFRAVIZhqwdQBw55AyVr6tYnJAc7v3HpqakY2mP4RJI60A4OcBtdCi0rs7LhNR4aB2sdOzZ09s3rwZTk5O8Pb2homJ6rvrc+fOaSw5IqJcu74H2NJH2bZxBfrtAJwrffDQXRceYdyWC1K7QZkSWD+4NkyMuEI5kT5Qu9gZOHAgIiMj0a9fP3ZQJiLdy34B7BoNXN6ujLX6Bqg3+oOHZmTLMGDdaZyOTpRiwV2rok8dT21kSkQ6onax888//+Dff/9FgwYNtJEPEVHuxZwC1gUq2yaWwOA9gFv1Dx665uhdfLPnmtQu42SNjUPqwNWOr+eJ9I3axY6HhwdnGSYi3ds/Ezi5VNmu1Anovv6DHZBvxaei1+pTSHyeJcWmBJbHqCal+aSaSE+pXewsWLAAU6dOxcqVK+Ht7a2FlIiI3iP5IbCuDZD8/2tTGRgB/f4ASr+5zt6rcmRyfLfvOtYci5ZiFVxs8PPAWnAvZqnNjIlIx9Qudvr164f09HSULl0alpaWb3RQTkxMfMeRREQfQS5TzJtzcokyVqkz0H3dB5/m3IxPxcB1pxGbnCHF5nSqjP4B3lpJlYgKFrWLnUWLFmkhDSKid5DLgJv/An+OADKSlfE+vwPlW7//ULnA9/tvYEXoHSlW06sY1g6sBXtLU21lTEQFTJ5GYxER5YvEaGDbICD2gjLmUVfx2srM+r2Hno95hsEhZ5CUni3FFvTwQ7ea7trJlYgKLLWLnZiYmPdu9/TkkE0i+kgZKUDYd0D4T8qYiy/Q5jvAq94HD19y6BYWHrgptRuVc8S3Xaqwbw5REaV2sePt7f3eEQsymeyd24iIPujoD8DhOaqx1t8BdUd88NCoh8mYvO0ibsSnSrGQwbXRpLyTprMkokJE7WLn/PnzKu3s7GycP38eCxcuxDfffKOxxIioiDn3i2I4+av9csq2ArqsAiwd3nuoEAL/23kZm08rnzw3KueIlf1qwNJU7R9zRKRn1P4p4Ofn90asVq1acHNzw/fff4+uXbtqJDEiKiJSYhXrWT08rYx51Qeafwl41v3g4QeuxmPYL2dVYpuG+aNe6RKazpSICimN/ZOnfPnyOHPmjKZOR0T6Ti4DDnz5Zr+c3psAe48PHp6cno12S4/h4bMXUqxqSTv8GVQfRoacHJCIlNQudlJSUlTaQgjExsZi1qxZKFu2rMYSIyI99vQOENIeSH2sjHVbC1TtnqvDD1+Px6chyqc5lVxtsaCnHyq6cnZ3InqT2sWOvb39Gx2UhRDw8PDAli1bNJYYEemhF8+AfTOAi5uVMVc/YMhBwPjD894kp2ej47LjuP80XYrNbFcRQxuW0ka2RKQn1C52Dh8+rFLsGBoawtHREWXKlIGxMTsCEtE7XNoG7BiqGuu8EqjW54OHCiHwxa7L+PWUsgNyqRJWWPpJdVR2s9N0pkSkZ9SuTpo0aaKFNIhIb2U9B3YMB67vVsaqdFfMmWP14U7Elx8lo/3S4yqxrzpUwuD6PprOlIj0lNrFTnBwMJydnfHpp5+qxNetW4cnT55g2rRpGkuOiAqx5/8BR74Bzq5TjY85BxQvnatTLD10CwtemRywXVVXLOpdDSZGhprMlIj0nNrFzqpVq7Bp06Y34pUrV0bv3r1Z7BAVZXIZ8PAMcHKp6pMcAGg4CWj2BfCeSUlfuvskDX1/jlBZuJOTAxJRXqld7MTFxcHV1fWNuKOjI2JjYzWSFBEVQrGXgJ+bA7Is1bhXA6D3r4BFsQ+eQiYX+N+OKPx+9oEU61HTHd90qQpTYz7NIaK8UbvY8fDwwIkTJ+Djo/q+/MSJE3Bzc9NYYkRUSGSlA6HBwMklypixBVB/LFDnM8CqeK5Ocys+FZ2WnUB6lnLJmTUDaqFlJWdNZ0xERYzaxc6wYcMwfvx4ZGdno1mzZgCAQ4cOYerUqZg0aZLGEySiAuxRJPBrd+BFojLWbwdQulmuXlcBiqc5c/+5ivUn7kmx8s422PBpHbjYmWs4YSIqitQudqZMmYKnT59i1KhRyMpSPK42NzfHtGnTMGPGDI0nSEQFkBDAxs7A3VBlrHJXoN2CD65j9aqoh8no8JPqSKt1g2qhWQU+zSEizTEQQoi8HJiWloZr167BwsICZcuWhZmZmaZzyzcpKSmws7NDcnIybG05AyvRe6XGAQvKq8Z6bAAqd871KYQQmLP7GtadiJZidXwcsOyTGnC0Kbw/S4gof+X293eeZwG0trZG7dq183o4ERU26YnAwVnAuQ3KmIc/8Om/uX5lBSj65rRefAwyufLfWYt7V0OnaiU1mCwRkRKnPCaiD7uwGfhzhLJtaKxYlbz+uFyfIlsmx9rj0Zi397oUC6zsjOV9a3LhTiLSKhY7RPRu/90Gtg0C4qOUsao9gM4rACOTXJ8mISUDdb49pBL7eUAttOBIKyLKByx2iOhN0UeB0O+A+690HjY2V7yycquW69MIITBv33WsCrsrxfx9HLCsbw2UsGbfHCLKHyx2iEgp6QGw8zPg/gnVeItZQL1xgGHuJ/Z7kJiOritO4klqphSb390XPWt5aChZIqLc0emUpEePHkWHDh3g5uYGAwMD/PnnnyrbhRD48ssv4erqCgsLC7Ro0QK3bt1S2ScxMRF9+/aFra0t7O3tMWTIEKSlpeXjtyDSEycWA4uqqBY6jacDMxOABhPUKnR+i7iPhvOPSIWOg5Upjk1tykKHiHRCp8XO8+fP4efnh2XLlr11+/z587FkyRKsXLkSERERsLKyQmBgIDIylOvl9O3bF1euXMGBAwewe/duHD16FMOHD8+vr0BU+D27D8xxBA58qYwFjAamPwCazgCMc/+6KUcmR/+1Efh852Up9r+2FXDui5bwcLDUZNZERLmW53l2NM3AwAA7d+5E586dASie6ri5uWHSpEmYPHkyACA5ORnOzs4ICQlB7969ce3aNVSqVAlnzpxBrVq1AAD79u1D27Zt8fDhw1wvX8F5dqjIOrYQOPS1su3hD/TfCZhaqX2q47f+w9gt55H4XLk21o5R9VDD88NrYhER5YXW59nRtujoaMTFxaFFixZSzM7ODv7+/ggPD0fv3r0RHh4Oe3t7qdABgBYtWsDQ0BARERHo0qXLW8+dmZmJzExlP4KUlBTtfRGigujhWWDrACDlkTLW9gegzjC1T5Ujk2PAutM4eeepFBvSwAeft60IQw4pJ6ICoMAWO3FxcQAAZ2fVoanOzs7Stri4ODg5OalsNzY2hoODg7TP2wQHB+Prr79+53YivZWRAuydClzcrIyVKAcM3pfrBTtfFX7nKfqtjVCZIPDI5CbwKaH+kyEiIm0psMWONs2YMQMTJ06U2ikpKfDwYMdJ0mNyGRAZAvyj/HsPAyPFfDl+vdQ/nVxg9OZz2BOl/EdFy0rOWNG3BoyNdNoVkIjoDQW22HFxcQEAxMfHw9XVVYrHx8ejWrVq0j4JCQkqx+Xk5CAxMVE6/m3MzMwK9VpeRGqJvQSsagTgle55tT4FWn0DmKrfafj4rf8w8tdIpGbmSLF94xuiggv7uxFRwVRg/wnm4+MDFxcXHDqknHU1JSUFERERCAgIAAAEBAQgKSkJkZGR0j6HDx+GXC6Hv79/vudMVKBkZwBbBwKrGkIqdIqXBUaGA+1/VLvQycqRY/ofl9BvbYRU6DSv4ITb37RhoUNEBZpOn+ykpaXh9u3bUjs6OhoXLlyAg4MDPD09MX78eMydOxdly5aFj48PvvjiC7i5uUkjtipWrIjWrVtj2LBhWLlyJbKzszF69Gj07t071yOxiPTSw7PAukBA/v9PX8zsgF6/AKWa5Ol0J+/8h74/R+DVsZvrBtVC0/JOMFBjEVAiIl3QabFz9uxZNG3aVGq/7EczcOBAhISEYOrUqXj+/DmGDx+OpKQkNGjQAPv27YO5ubl0zG+//YbRo0ejefPmMDQ0RLdu3bBkyZJ8/y5EBYJcDoTNA8K+U8YqdgA6LQPM7dQ+XVaOHDN2ROGPcw+l2NhmZRDUrAzMjI00kTERkdYVmHl2dInz7JBeeHYPCGkPJD9QxnpsACp3ztPpIu8/w6chZ5D8IhsAYGZsiO0j6qGqu/pFExGRNhT6eXaISA3HFgCHZivbHv5A1zVAMS+1TyWEwPf/3sDy0DtSrG1VFyzsWQ3mJnyaQ0SFD4sdosIs6QGwsQvw9JU14wK/BeqOAvLQl+bCgyR0X3ESOa/Mm7NpmD/qlS6hiWyJiHSCxQ5RYSSXAScWqT7NKVkL6LcdsFB/eYaMbBnm7b2OkJP3pFiT8o5Y0bcmLEz5NIeICjcWO0SFzcOzwM/NVWOdlgHV++XpdJcfJaP90uMqsV8+rYNG5RzzmiERUYHCYoeosMhMA/ZOAy78qoxV6gS0ngfYqj/VwvPMHEzedhF7LytnQW5b1QWLe1eHCWdBJiI9wmKHqDC4tA3YORwQcmWs6xrAt2eeTrfvciw+33kZT/9/hXIHK1Ms6V0dDcqybw4R6R8WO0QFWXYG8McQ4PpuZaxaX6DDYsDIRO3TZWTLMGDdaZyOTpRi/et64asOlbimFRHpLRY7RAXV/ZPA+jbKtoUD8NlRwD5vi9Yeu/UEA9edxsuBVuWdbfBDDz/Om0NEeo/FDlFBI8sGVjUGEq4oY/4jgBazABMLtU+XlpmD0ZvOIfTGEynWv64XZneqzKUeiKhIYLFDVJCc2wj8NVrZtigGDNgFuPrl6XRn7iWi56pwaU0rJxszfN/DD4050oqIihAWO0QFQfIjYMcw4P4JZazBRKD5l3maHBAAfj52F3P/uSa1P2tUCtNaV4ChIZ/mEFHRwmKHSJceXwD2TAEenlbGTKyAkccBh1J5OuWT1Ex0X3kS95+mS7ENn9bh0xwiKrJY7BDpQmoc8M8k1VFWABAwGmg5BzDM28iob/dcw+qjd6V2NQ97bBxSBzbm6o/cIiLSFyx2iPKTEMD+mUD4T8qYuT0QEKQodEwt83Ta+0+fo9eqU4hLyZBi33f3RY9aeRu5RUSkT1jsEOWX2EvA5t5AyiNlrO0PQJ1hH3XaVWF3ELz3utT2dbfD1s8CuEI5EdH/Y7FDpG1CAMd+AA7PVcZcqgL9dgLWee9Hk5CSgZ6rwnHvlb45czpXQf+6Xh+TLRGR3mGxQ6QtT24Af44CHp1VjXdYAtQYkOdRVgDw98XHGLP5vNS2szDBvvEN4Wqn/jw8RET6jsUOkSYJAVz9EzjyLfDfTdVtNQYqJga0dMjz6VMysvHFn5ex68JjKdavridmd6zCIeVERO/AYodIUxKuAasaAbIsZczOQ7EyeeOpgPnHLcuw+XQMvv77CjKylYuB7gqqDz8P+486LxGRvmOxQ/Sx5HJg7xTgzM/KmFcDoPW3eZ75+FXPnmfhs18jVRbvHFTPG9PbVGAnZCKiXGCxQ/QxHp4FNnQAspWdhNF9PVClq0ZOv+vCI4zbckEltmmoP+qVKaGR8xMRFQUsdojyIicL+GcCcP5XZcynMdBr40e/rgKAHJkc43+/gN2XYqVYnzoemN6mIuwsOEEgEZE6WOwQqUMI4NrfwD8TgefKVcTRIwSo3EUjl4i8/wzdVpxUiR2f1hTuxfI24SARUVHHYocot54/BTb1AB5FKmNVugEdFgNmNhq5xBd/XsbGU/eldvMKTljVvyaMjfK2fAQREbHYIfowWTZwYjFweI4y5lRJsSJ5+TYauURs8gu0+vEoUjNypNi/4xuhvItmiigioqKMxQ7Ru2RnAHePAFsHqA4nrzdGsVjnR0wK+KrXOyFX97THluF1YWbMkVZERJrAYofodXI5EPqt4mnOq0WOS1Wg7QLA018jl8nKkaP/2ghEvDKk/NsuVfGJv6dGzk9ERAosdohelfwIWNUQSH+qjLnXARpO1NgrKwA4dfcpeq8+JbVdbM2xY1Q9uNlzuQciIk1jsUP00v4vgJNLlG1bd+CT3wGXKhq7xLPnWZiy/RIOXouXYuNblMX4FuU0dg0iIlLFYofowWlgcx8g/T9lrNMyoFpfjfXLAYBLD5PQY2U4MnOUyz1wgkAiIu1jsUNFlywH2DYQuL5bGSvmA4w4prGh5ACQkS3D9//ewNrj0VKsVy0PfNOlCoeUExHlAxY7VDRd+VNR6LxkYAT03gSUC9To05wbcanovvKkypDyLcProm6p4hq7BhERvR+LHSpa0hOBTT2Bh2eUsTqfAW3na/QyQggsPnQLiw7ekmId/NzwbZcqsDHncg9ERPmJxQ4VHYfmAMd+ULatXYDBe4DipTV6mUdJL9Dsh1CVvjmr+tdEYGUXjV6HiIhyh8UO6b/oY8CvXV+bGHAs0HK2Rl9ZAcAv4ffw5a4rUtvPwx7rBtZCcWszjV6HiIhyr0D3jpw1axYMDAxU/lSoUEHanpGRgaCgIBQvXhzW1tbo1q0b4uPj33NGKlLkcmBLX2BDe2WhU7ImMDoSaKW5GZABIPlFNrqtOKlS6HzetiJ2BdVnoUNEpGMF/slO5cqVcfDgQaltbKxMecKECfjnn3+wbds22NnZYfTo0ejatStOnDihi1SpIEm8C/xUB5BnK2MjwwHnShq/1J6oWIz67ZzU9vOwx4q+NThBIBFRAVHgix1jY2O4uLzZ1yE5ORlr167Fpk2b0KxZMwDA+vXrUbFiRZw6dQp169bN71SpIBACOL4QODRbGStRDhhxAjA21eil0rNyMG7LBRy4qnya+EX7ShjSwEej1yEioo9T4IudW7duwc3NDebm5ggICEBwcDA8PT0RGRmJ7OxstGjRQtq3QoUK8PT0RHh4+HuLnczMTGRmZkrtlJQUrX4HyidJMcCGDsCze8pYx5+AGv01fqmd5x9iwu8XpbabnTnWDqqNiq62Gr8WERF9nAJd7Pj7+yMkJATly5dHbGwsvv76azRs2BCXL19GXFwcTE1NYW9vr3KMs7Mz4uLi3nve4OBgfP3111rMnPLdyZ+A/Z8r2x7+QJ8tgKWDRi+TkJqBz3deVnma07V6Sczr5gtT4wLdBY6IqMgq0MVOmzbKhRd9fX3h7+8PLy8vbN26FRYWee8PMWPGDEycOFFqp6SkwMPD46NyJR3JzgB+bgHERyljrecBdUdq/FK/RdzH5zsvS+0KLjYIGVwHLnbmGr8WERFpToEudl5nb2+PcuXK4fbt22jZsiWysrKQlJSk8nQnPj7+rX18XmVmZgYzM46QKdSEAM79AuweDwjlfDYIOg04ltfopZLTs9F37SlcfqR83TmnU2X0D/DW6HWIiEg7CtVz97S0NNy5cweurq6oWbMmTExMcOjQIWn7jRs3EBMTg4CAAB1mSVolBHBpGzDbAfh7rLLQqT0U+OKpxgudzadj4Dd7v1To+Lrb4dSM5ix0iIgKkQL9ZGfy5Mno0KEDvLy88PjxY3z11VcwMjJCnz59YGdnhyFDhmDixIlwcHCAra0txowZg4CAAI7E0lep8cDvfVWXenD1A/r8Dti6avRSDxLTMeH3Czh7/5kUG9e8LCa0LKfR6xARkfYV6GLn4cOH6NOnD54+fQpHR0c0aNAAp06dgqOjIwDgxx9/hKGhIbp164bMzEwEBgZi+fLlOs6atOLa38Dv/VRjQw8D7jU1fqm1x6MxZ/dVqe3v44Cln1SHkw375hARFUYGQgih6yR0LSUlBXZ2dkhOToatLYcOFygPI4Ejc4E7h5Wx2sOA5l8C5pr9b5WQkoHuK8MRk5guxX75tA4alXPU6HWIiEgzcvv7u0A/2aEiLDUeWN8GSLyjGu//J1C6qUYvJZcL/BpxX2Wph/LONtg1uj7MTYw0ei0iIsp/LHaoYMnJAnYMBa7uUsYMTYDWwUD1/oCJZl8lPU3LRIPvjuBFtkyKze1cBf3qemn0OkREpDssdqhgSE8ETi4Bjv+ojBmbA3VHAc1mAoaafcIihMCaY3fx7Z7rUqyUoxV2jqoPOwsTjV6LiIh0i8UO6ZYQwMUtwJ8jVOONpgBNP9foyuQvRT1MxoStF3A7IU2Kze5UGf3resFAC9cjIiLdYrFDuvP4PPD7ACA5Rhmr0B7ouFTjyzwAQGaODAv338Sqo3elWJPyjljcqzrsLPk0h4hIX7HYofyXmaZ4XXXsB2XMuQrQaRngVk0rl7z6OAX91kYg8XmWFFvRtwbaVNXs/DxERFTwsNih/JP8ELi+B9g/E5C9XHXeAOj5C1Cpo1Yu+SJLhsnbLuKfqFgpVtrRCiGD68DDwVIr1yQiooKFxQ5p34klQPhPQFq8arzmIKDNfMBYO+uULQ+9jfn7bqjE5nf3Rfca7jA0ZN8cIqKigsUOac/pNcCBL4Fs5SR9sHIEvBsAfp8A5Vpp5bIxT9MxZvM5XHyYLMV61HTHjLYV4WBlqpVrEhFRwcVihzTvRRKwtiXw301lzLMe0G0NYOeu1UuP+i0Se6LipLa1mTG2fhaASm6cGZuIqKhisUOa9foaVlZOwGdhgK2bVi975l4ieq0Kh/yVxU/mdK6CvnU8+cqKiKiIY7FDmiHLBjb3Bm4fVMaazAAaT9PKXDkvnb2XiHl7r6usTl7H2wGbhvnD2MhQa9clIqLCg8UOfRy5HDg8Bzi+UBlzrQb03AAU89baZZPTszFqUyRO3H6qEv9tqD/qlymhtesSEVHhw2KH8u5RJLD5EyBN2UcGzb4AGk3W2iUj7z/D7L+vqHQ+BoDPGpXCuBZlYWnKv9JERKSKvxlIfUIAYfOB0G+VsTItgJ4bAVPNz12TmSPD3xdjsevCIxy79Z/KtmENfTC6aVnOgExERO/EYofUc3oNcHAWkPVyXSkDoN8fQJnmGr/U5UfJ+C0iBptPx7yxjSuTExFRbrHYodxJfgT8WEk1VrYV0HkFYKW5PjIPn6Vj3fF7OHw9HveepqtsK+tkjTHNy6KDrysX7CQiolxjsUPvl5MJ7BwBXNmhjDlVAvps1lgHZLlcYM2xuwi7+QQn76h2OHawMkW/ul4YXM8bxTghIBER5QGLHXq3uMvAmqaATLl4JtrMB/w/08jpE1IzsOzwbfwWEYOcVyfIAdCykjM+8fdEk3KOfIpDREQfhcUOvUkI4OQSxVIPL/n1ATr+BBh93F8ZIQTWHo/GvstxKnPjAIB3cUtMaFkOrau4wMzY6KOuQ0RE9BKLHVL1/KliqYfEO8pYn9+B8q3zfEohBKIeJSPk5D3sOPdIZZuDlSn6+XtieOPSsDbjX0ciItI8/nYhpXsngJC2yrZ3Q6DHBsCqeJ5Ol/wiG9sjH+Knw7fwLD1bZVspRyvM6lAZDcuW4GsqIiLSKhY7BMhygD+GAFf/VMZazAIaTMjT6a48Tsbsv68iIjpRJW5hYoQB9bwwpIEPnGzM854vERGRGljsFHVPbgK/dAJSHytjQw8D7jXVOk3i8yxsPfsAuy89xuVHKSrbmlVwwtCGPggoVZxPcYiIKN+x2CmqhFAMKb+0RRnzbqgYUm5mk+vTRNx9im/3XsfFB0kqcXMTQ4xpVhZ96njCgUPGiYhIh1jsFEUPTgPr2wDyHEXbzhNotwAo1ypXh7/IkmHuP1ex93IcEp9nqWzrXtMd3Wq4o24pBz7FISKiAoHFTlEiBBA6Dwibp4zVHga0++GDh2blyLH70mP8dOQ27j55rrLNvZgFBgZ4o0ctd9hb8ikOEREVLCx2ior4K8CKeqqxT/8FPOu+97A7T9Kw8MBN/HMpViVuaAC0ruKCIQ1KoYanPZ/iEBFRgcViR9/JZcCuIODiZmWsQnvFkPJ3TBD4X1omdpx7iN/PPMCd157i1PQqhl61PdCthjuMDFngEBFRwcdiR589Ogf82hV48cpMxb03AxXavrFrWmYOTkc/xcbw+zhy44nKtmKWJuhUrSQG1fOGdwkrbWdNRESkUSx29JFcBvwzCYhcr4xV7gJ0WQ0YK/vUPEp6gY3h93Hi9n+IepT8xmm613THwABvVHW3y4+siYiItILFjr757xawugmQlaaM9f0DKNsCQgjsjYrF4esJOHX3KR4+e/HG4V7FLdHX3xN9/b1gxeUbiIhID/C3mT4JXw78O0Nqysu2xkHfBfj3/FNE7Q7Dzfi0tx7m52GP0U3LoLqnPUpYm+VXtkRERPmCxU5hJ5cBh+cqXlm90jdnofVkLImqAURdVNnd0ACoW6o4mpR3RIMyjijtZMUVxomISK+x2CnEMi9sh+muYTAQcil2Xl4Go7LGITZDuXhnBRcb1CtdAh38XFGlpB1MjAx1kS4REZFO6E2xs2zZMnz//feIi4uDn58fli5dijp16ug6Lc2Ry5B6YQcS70Qi5dFNOCdfgJN4Km2+IC+N0dlj8VA4opyzNQJLl0DLSs7w93GAMYsbIiIqwvSi2Pn9998xceJErFy5Ev7+/li0aBECAwNx48YNODk56To99ciygfREIP4y0uNuIv7+dZjGnUfJ1IuwAfD6qlVH5b446NAbdpVa4FtvB9TyLgZLU734z0pERKQRBkIIoeskPpa/vz9q166Nn376CQAgl8vh4eGBMWPGYPr06R88PiUlBXZ2dkhOToatra3G8kp4FA1ZjuraUQbZ6TBOvg9A4Hl6BjL+uweLtPswfBYNy7QY2GfFwRDyt58QwAlZZTy1Lgsbl9Lw8u8Er3K+nNyPiIiKpNz+/i70jwCysrIQGRmJGTOUo5AMDQ3RokULhIeHv/WYzMxMZGZmSu2UlBSt5Jaxth085Y/eub3Ee45NEZZ4IBxx36AkMq09kO7oB8caHdCkkjtMjflaioiIKLcKfbHz33//QSaTwdnZWSXu7OyM69evv/WY4OBgfP3111rPLQcmyBAmb8STYIM4OMAAAIxMkWTihARjN6TbeEE4VYZNyfJwLeGAUiWsUdnOXOt5EhER6bNCX+zkxYwZMzBx4kSpnZKSAg8PD41fp9SXF98ad/n/P0RERKR9hb7YKVGiBIyMjBAfH68Sj4+Ph4vL20sKMzMzmJlx8jwiIqKioNB3/jA1NUXNmjVx6NAhKSaXy3Ho0CEEBAToMDMiIiIqCAr9kx0AmDhxIgYOHIhatWqhTp06WLRoEZ4/f47BgwfrOjUiIiLSMb0odnr16oUnT57gyy+/RFxcHKpVq4Z9+/a90WmZiIiIih69mGfnY2lrnh0iIiLSntz+/i70fXaIiIiI3ofFDhEREek1FjtERESk11jsEBERkV5jsUNERER6jcUOERER6TUWO0RERKTXWOwQERGRXmOxQ0RERHpNL5aL+FgvJ5FOSUnRcSZERESUWy9/b39oMQgWOwBSU1MBAB4eHjrOhIiIiNSVmpoKOzu7d27n2lgA5HI5Hj9+DBsbGxgYGGjsvCkpKfDw8MCDBw+45tYH8F6ph/cr93ivco/3Kvd4r3JPm/dKCIHU1FS4ubnB0PDdPXP4ZAeAoaEh3N3dtXZ+W1tb/s+QS7xX6uH9yj3eq9zjvco93qvc09a9et8TnZfYQZmIiIj0GosdIiIi0mssdrTIzMwMX331FczMzHSdSoHHe6Ue3q/c473KPd6r3OO9yr2CcK/YQZmIiIj0Gp/sEBERkV5jsUNERER6jcUOERER6TUWO0RERKTXWOxo0bJly+Dt7Q1zc3P4+/vj9OnTuk5Jq44ePYoOHTrAzc0NBgYG+PPPP1W2CyHw5ZdfwtXVFRYWFmjRogVu3bqlsk9iYiL69u0LW1tb2NvbY8iQIUhLS1PZ59KlS2jYsCHMzc3h4eGB+fPna/uraVxwcDBq164NGxsbODk5oXPnzrhx44bKPhkZGQgKCkLx4sVhbW2Nbt26IT4+XmWfmJgYtGvXDpaWlnBycsKUKVOQk5Ojsk9oaChq1KgBMzMzlClTBiEhIdr+ehq1YsUK+Pr6ShOSBQQEYO/evdJ23qd3mzdvHgwMDDB+/HgpxvulNGvWLBgYGKj8qVChgrSd90rVo0eP0K9fPxQvXhwWFhaoWrUqzp49K20v0D/jBWnFli1bhKmpqVi3bp24cuWKGDZsmLC3txfx8fG6Tk1r9uzZIz7//HOxY8cOAUDs3LlTZfu8efOEnZ2d+PPPP8XFixdFx44dhY+Pj3jx4oW0T+vWrYWfn584deqUOHbsmChTpozo06ePtD05OVk4OzuLvn37isuXL4vNmzcLCwsLsWrVqvz6mhoRGBgo1q9fLy5fviwuXLgg2rZtKzw9PUVaWpq0z4gRI4SHh4c4dOiQOHv2rKhbt66oV6+etD0nJ0dUqVJFtGjRQpw/f17s2bNHlChRQsyYMUPa5+7du8LS0lJMnDhRXL16VSxdulQYGRmJffv25ev3/Rh//fWX+Oeff8TNmzfFjRs3xP/+9z9hYmIiLl++LITgfXqX06dPC29vb+Hr6yvGjRsnxXm/lL766itRuXJlERsbK/158uSJtJ33SikxMVF4eXmJQYMGiYiICHH37l3x77//itu3b0v7FOSf8Sx2tKROnToiKChIastkMuHm5iaCg4N1mFX+eb3YkcvlwsXFRXz//fdSLCkpSZiZmYnNmzcLIYS4evWqACDOnDkj7bN3715hYGAgHj16JIQQYvny5aJYsWIiMzNT2mfatGmifPnyWv5G2pWQkCAAiLCwMCGE4t6YmJiIbdu2Sftcu3ZNABDh4eFCCEVxaWhoKOLi4qR9VqxYIWxtbaX7M3XqVFG5cmWVa/Xq1UsEBgZq+ytpVbFixcTPP//M+/QOqampomzZsuLAgQOicePGUrHD+6Xqq6++En5+fm/dxnulatq0aaJBgwbv3F7Qf8bzNZYWZGVlITIyEi1atJBihoaGaNGiBcLDw3WYme5ER0cjLi5O5Z7Y2dnB399fuifh4eGwt7dHrVq1pH1atGgBQ0NDRERESPs0atQIpqam0j6BgYG4ceMGnj17lk/fRvOSk5MBAA4ODgCAyMhIZGdnq9yvChUqwNPTU+V+Va1aFc7OztI+gYGBSElJwZUrV6R9Xj3Hy30K699DmUyGLVu24Pnz5wgICOB9eoegoCC0a9fuje/E+/WmW7duwc3NDaVKlULfvn0RExMDgPfqdX/99Rdq1aqFHj16wMnJCdWrV8eaNWuk7QX9ZzyLHS3477//IJPJVP4HAABnZ2fExcXpKCvdevm933dP4uLi4OTkpLLd2NgYDg4OKvu87RyvXqOwkcvlGD9+POrXr48qVaoAUHwXU1NT2Nvbq+z7+v360L141z4pKSl48eKFNr6OVkRFRcHa2hpmZmYYMWIEdu7ciUqVKvE+vcWWLVtw7tw5BAcHv7GN90uVv78/QkJCsG/fPqxYsQLR0dFo2LAhUlNTea9ec/fuXaxYsQJly5bFv//+i5EjR2Ls2LHYsGEDgIL/M56rnhPpWFBQEC5fvozjx4/rOpUCq3z58rhw4QKSk5Oxfft2DBw4EGFhYbpOq8B58OABxo0bhwMHDsDc3FzX6RR4bdq0kT77+vrC398fXl5e2Lp1KywsLHSYWcEjl8tRq1YtfPvttwCA6tWr4/Lly1i5ciUGDhyo4+w+jE92tKBEiRIwMjJ6o9d+fHw8XFxcdJSVbr383u+7Jy4uLkhISFDZnpOTg8TERJV93naOV69RmIwePRq7d+/GkSNH4O7uLsVdXFyQlZWFpKQklf1fv18fuhfv2sfW1rZQ/TA3NTVFmTJlULNmTQQHB8PPzw+LFy/mfXpNZGQkEhISUKNGDRgbG8PY2BhhYWFYsmQJjI2N4ezszPv1Hvb29ihXrhxu377Nv1uvcXV1RaVKlVRiFStWlF77FfSf8Sx2tMDU1BQ1a9bEoUOHpJhcLsehQ4cQEBCgw8x0x8fHBy4uLir3JCUlBREREdI9CQgIQFJSEiIjI6V9Dh8+DLlcDn9/f2mfo0ePIjs7W9rnwIEDKF++PIoVK5ZP3+bjCSEwevRo7Ny5E4cPH4aPj4/K9po1a8LExETlft24cQMxMTEq9ysqKkrlh8eBAwdga2sr/VAKCAhQOcfLfQr730O5XI7MzEzep9c0b94cUVFRuHDhgvSnVq1a6Nu3r/SZ9+vd0tLScOfOHbi6uvLv1mvq16//xvQYN2/ehJeXF4BC8DP+o7o30ztt2bJFmJmZiZCQEHH16lUxfPhwYW9vr9JrX9+kpqaK8+fPi/PnzwsAYuHCheL8+fPi/v37QgjFsER7e3uxa9cucenSJdGpU6e3DkusXr26iIiIEMePHxdly5ZVGZaYlJQknJ2dRf/+/cXly5fFli1bhKWlZaEbej5y5EhhZ2cnQkNDVYa9pqenS/uMGDFCeHp6isOHD4uzZ8+KgIAAERAQIG1/Oey1VatW4sKFC2Lfvn3C0dHxrcNep0yZIq5duyaWLVtW6Ia9Tp8+XYSFhYno6Ghx6dIlMX36dGFgYCD2798vhOB9+pBXR2MJwfv1qkmTJonQ0FARHR0tTpw4IVq0aCFKlCghEhIShBC8V686ffq0MDY2Ft988424deuW+O2334SlpaX49ddfpX0K8s94FjtatHTpUuHp6SlMTU1FnTp1xKlTp3SdklYdOXJEAHjjz8CBA4UQiqGJX3zxhXB2dhZmZmaiefPm4saNGyrnePr0qejTp4+wtrYWtra2YvDgwSI1NVVln4sXL4oGDRoIMzMzUbJkSTFv3rz8+ooa87b7BECsX79e2ufFixdi1KhRolixYsLS0lJ06dJFxMbGqpzn3r17ok2bNsLCwkKUKFFCTJo0SWRnZ6vsc+TIEVGtWjVhamoqSpUqpXKNwuDTTz8VXl5ewtTUVDg6OormzZtLhY4QvE8f8nqxw/ul1KtXL+Hq6ipMTU1FyZIlRa9evVTmjeG9UvX333+LKlWqCDMzM1GhQgWxevVqle0F+We8gRBC5P25EBEREVHBxj47REREpNdY7BAREZFeY7FDREREeo3FDhEREek1FjtERESk11jsEBERkV5jsUNERER6jcUOERER6TUWO0SUL0JDQ2FgYPDGwopERNrGYoeINK5JkyYYP368SqxevXqIjY2FnZ2dbpJ6B29vbyxatEjXaRCRFhnrOgEiKhpMTU3h4uKi6zSIqAjikx0i0qhBgwYhLCwMixcvhoGBAQwMDHDv3r03XmOFhITA3t4eu3fvRvny5WFpaYnu3bsjPT0dGzZsgLe3N4oVK4axY8dCJpNJ58/MzMTkyZNRsmRJWFlZwd/fH6Ghoe/MRwiBWbNmwdPTE2ZmZnBzc8PYsWMBKJ5A3b9/HxMmTJByfen48eNo2LAhLCws4OHhgbFjx+L58+fSdm9vb8yZMwd9+vSBlZUVSpYsiWXLluXqukSUzz56KVEiolckJSWJgIAAMWzYMBEbGytiY2NFTk6OOHLkiAAgnj17JoQQYv369cLExES0bNlSnDt3ToSFhYnixYuLVq1aiZ49e4orV66Iv//+W5iamootW7ZI5x86dKioV6+eOHr0qLh9+7b4/vvvhZmZmbh58+Zb89m2bZuwtbUVe/bsEffv3xcRERHSas1Pnz4V7u7uYvbs2VKuQghx+/ZtYWVlJX788Udx8+ZNceLECVG9enUxaNAg6bxeXl7CxsZGBAcHixs3boglS5YIIyMjaUX2912XiPIXix0i0rjGjRuLcePGqcTeVuwAELdv35b2+eyzz4SlpaVITU2VYoGBgeKzzz4TQghx//59YWRkJB49eqRy7ubNm4sZM2a8NZcFCxaIcuXKiaysrLdu9/LyEj/++KNKbMiQIWL48OEqsWPHjglDQ0Px4sUL6bjWrVur7NOrVy/Rpk2bXF2XiPIPX2MRkc5YWlqidOnSUtvZ2Rne3t6wtrZWiSUkJAAAoqKiIJPJUK5cOVhbW0t/wsLCcOfOnbdeo0ePHnjx4gVKlSqFYcOGYefOncjJyXlvXhcvXkRISIjKNQIDAyGXyxEdHS3tFxAQoHJcQEAArl27lufrEpF2sIMyEemMiYmJStvAwOCtMblcDgBIS0uDkZERIiMjYWRkpLLfqwXSqzw8PHDjxg0cPHgQBw4cwKhRo/D9998jLCzsjWu9lJaWhs8+++ytfWw8PT1z9d3ycl0i0g4WO0SkcaampiqdijWlevXqkMlkSEhIQMOGDXN9nIWFBTp06IAOHTogKCgIFSpUQFRUFGrUqPHWXGvUqIGrV6+iTJky7z3vqVOn3mhXrFgxV9clovzDYoeINM7b2xsRERG4d+8erK2t4eDgoJHzlitXDn379sWAAQOwYMECVK9eHU+ePMGhQ4fg6+uLdu3avXFMSEgIZDIZ/P39YWlpiV9//RUWFhbw8vKScj169Ch69+4NMzMzlChRAtOmTUPdunUxevRoDB06FFZWVrh69SoOHDiAn376STr3iRMnMH/+fHTu3BkHDhzAtm3b8M8//+TqukSUf9hnh4g0bvLkyTAyMkKlSpXg6OiImJgYjZ17/fr1GDBgACZNmoTy5cujc+fOOHPmzDtfL9nb22PNmjWoX78+fH19cfDgQfz9998oXrw4AGD27Nm4d+8eSpcuDUdHRwCAr68vwsLCcPPmTTRs2BDVq1fHl19+CTc3N5VzT5o0CWfPnkX16tUxd+5cLFy4EIGBgbm6LhHlHwMhhNB1EkREhY23tzfGjx//xkzRRFTw8MkOERER6TUWO0RERKTX+BqLiIiI9Bqf7BAREZFeY7FDREREeo3FDhEREek1FjtERESk11jsEBERkV5jsUNERER6jcUOERER6TUWO0RERKTX/g8JOrlSrqMZ3QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_8_5()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model containing a priority queue for Prioritized Sweeping\n",
    "class PriorityModel(TrivialModel):\n",
    "    def __init__(self, rand=np.random):\n",
    "        TrivialModel.__init__(self, rand)\n",
    "        # maintain a priority queue\n",
    "        self.priority_queue = PriorityQueue()\n",
    "        # track predecessors for every state\n",
    "        self.predecessors = dict()\n",
    "    \n",
    "    # add a @state-@action pair into the priority queue with priority @priority\n",
    "    def insert(self, priority, state, action):\n",
    "        # note the priority queue is a minimum heap, so we use -priority\n",
    "        self.priority_queue.add_item((tuple(state), action), -priority)\n",
    "\n",
    "\n",
    "    # get the first item in the priority queue\n",
    "    def sample(self):\n",
    "        (state, action), priority = self.priority_queue.pop_item()\n",
    "        next_state, reward = self.model[state][action]\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        return -priority, list(state), action, list(next_state), reward\n",
    "\n",
    "    # @return: whether the priority queue is empty\n",
    "    def empty(self):\n",
    "        return self.priority_queue.empty()\n",
    "\n",
    "    # feed the model with previous experience\n",
    "    def feed(self, state, action, next_state, reward):\n",
    "        state = deepcopy(state)\n",
    "        next_state = deepcopy(next_state)\n",
    "        TrivialModel.feed(self, state, action, next_state, reward)\n",
    "        if tuple(next_state) not in self.predecessors.keys():\n",
    "            self.predecessors[tuple(next_state)] = set()\n",
    "        self.predecessors[tuple(next_state)].add((tuple(state), action))\n",
    "\n",
    "    # get all seen predecessors of a state @state\n",
    "    def predecessor(self, state):\n",
    "        if tuple(state) not in self.predecessors.keys():\n",
    "            return []\n",
    "        predecessors = []\n",
    "        for state_pre, action_pre in list(self.predecessors[tuple(state)]):\n",
    "            predecessors.append([list(state_pre), action_pre, self.model[state_pre][action_pre][1]])\n",
    "        return predecessors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# play for an episode for prioritized sweeping algorithm\n",
    "# @q_value: state action pair values, will be updated\n",
    "# @model: model instance for planning\n",
    "# @maze: a maze instance containing all information about the environment\n",
    "# @dyna_params: several params for the algorithm\n",
    "# @return: # of backups during this episode\n",
    "def prioritized_sweeping(q_value, model, maze, dyna_params):\n",
    "    state = maze.START_STATE\n",
    "\n",
    "    # track the steps in this episode\n",
    "    steps = 0\n",
    "\n",
    "    # track the backups in planning phase\n",
    "    backups = 0\n",
    "\n",
    "    while state not in maze.GOAL_STATES:\n",
    "        steps += 1\n",
    "\n",
    "        # get action\n",
    "        action = choose_action(state, q_value, maze, dyna_params)\n",
    "\n",
    "        # take action\n",
    "        next_state, reward = maze.step(state, action)\n",
    "\n",
    "        # feed the model with experience\n",
    "        model.feed(state, action, next_state, reward)\n",
    "\n",
    "        # get the priority for current state action pair\n",
    "        priority = np.abs(reward + dyna_params.gamma * np.max(q_value[next_state[0], next_state[1], :]) -\n",
    "                          q_value[state[0], state[1], action])\n",
    "\n",
    "\n",
    "        if priority > dyna_params.theta:\n",
    "            model.insert(priority, state, action)\n",
    "\n",
    "        # start planning\n",
    "        planning_step = 0\n",
    "\n",
    "        # planning for several steps,\n",
    "        # although keep planning until the priority queue becomes empty will converge much faster\n",
    "        while planning_step < dyna_params.planning_steps and not model.empty():\n",
    "            # get a sample with highest priority from the model\n",
    "            priority, state_, action_, next_state_, reward_ = model.sample()\n",
    "\n",
    "            # update the state action value for the sample\n",
    "            delta = reward_ + dyna_params.gamma * np.max(q_value[next_state_[0], next_state_[1], :]) - \\\n",
    "                    q_value[state_[0], state_[1], action_]\n",
    "            q_value[state_[0], state_[1], action_] += dyna_params.alpha * delta\n",
    "\n",
    "\n",
    "            # deal with all the predecessors of the sample state\n",
    "            for state_pre, action_pre, reward_pre in model.predecessor(state_):\n",
    "                priority = np.abs(reward_pre + dyna_params.gamma * np.max(q_value[state_[0], state_[1], :]) -\n",
    "                                  q_value[state_pre[0], state_pre[1], action_pre])\n",
    "                if priority > dyna_params.theta:\n",
    "                    model.insert(priority, state_pre, action_pre)\n",
    "            planning_step += 1\n",
    "\n",
    "        state = next_state\n",
    "\n",
    "        # update the # of backups\n",
    "        backups += planning_step + 1\n",
    "\n",
    "    return backups\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Check whether state-action values are already optimal\n",
    "def check_path(q_values, maze):\n",
    "    # get the length of optimal path\n",
    "    # 14 is the length of optimal path of the original maze\n",
    "    # 1.2 means it's a relaxed optifmal path\n",
    "    max_steps = 14 * maze.resolution * 1.2\n",
    "    state = maze.START_STATE\n",
    "    steps = 0\n",
    "    while state not in maze.GOAL_STATES:\n",
    "        action = np.argmax(q_values[state[0], state[1], :])\n",
    "        state, _ = maze.step(state, action)\n",
    "        steps += 1\n",
    "        if steps > max_steps:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Example 8.4, mazes with different resolution\n",
    "def example_8_4():\n",
    "    # get the original 6 * 9 maze\n",
    "    original_maze = Maze()\n",
    "\n",
    "    # set up the parameters for each algorithm\n",
    "    params_dyna = DynaParams()\n",
    "    params_dyna.planning_steps = 5\n",
    "    params_dyna.alpha = 0.5\n",
    "    params_dyna.gamma = 0.95\n",
    "\n",
    "    params_prioritized = DynaParams()\n",
    "    params_prioritized.theta = 0.0001\n",
    "    params_prioritized.planning_steps = 5\n",
    "    params_prioritized.alpha = 0.5\n",
    "    params_prioritized.gamma = 0.95\n",
    "\n",
    "    params = [params_prioritized, params_dyna]\n",
    "\n",
    "    # set up models for planning\n",
    "    models = [PriorityModel, TrivialModel]\n",
    "    method_names = ['Prioritized Sweeping', 'Dyna-Q']\n",
    "\n",
    "    # due to limitation of my machine, I can only perform experiments for 5 mazes\n",
    "    # assuming the 1st maze has w * h states, then k-th maze has w * h * k * k states\n",
    "    num_of_mazes = 5\n",
    "\n",
    "    # build all the mazes\n",
    "    mazes = [original_maze.extend_maze(i) for i in range(1, num_of_mazes + 1)]\n",
    "    methods = [prioritized_sweeping, dyna_q]\n",
    "\n",
    "    # My machine cannot afford too many runs...\n",
    "    runs = 5\n",
    "\n",
    "    # track the # of backups\n",
    "    backups = np.zeros((runs, 2, num_of_mazes))\n",
    "\n",
    "    for run in range(0, runs):\n",
    "        for i in range(0, len(method_names)):\n",
    "            for mazeIndex, maze in zip(range(0, len(mazes)), mazes):\n",
    "                print('run %d, %s, maze size %d' % (run, method_names[i], maze.WORLD_HEIGHT * maze.WORLD_WIDTH))\n",
    "\n",
    "                # initialize the state action values\n",
    "                q_value = np.zeros(maze.q_size)\n",
    "\n",
    "                # track steps / backups for each episode\n",
    "                steps = []\n",
    "\n",
    "                # generate the model\n",
    "                model = models[i]()\n",
    "\n",
    "                # play for an episode\n",
    "                while True:\n",
    "                    steps.append(methods[i](q_value, model, maze, params[i]))\n",
    "\n",
    "                    # print best actions w.r.t. current state-action values\n",
    "                    # printActions(currentStateActionValues, maze)\n",
    "\n",
    "                    # check whether the (relaxed) optimal path is found\n",
    "                    if check_path(q_value, maze):\n",
    "                        break\n",
    "\n",
    "                # update the total steps / backups for this maze\n",
    "                backups[run, i, mazeIndex] = np.sum(steps)\n",
    "\n",
    "    backups = backups.mean(axis=0)\n",
    "\n",
    "    # Dyna-Q performs several backups per step\n",
    "    backups[1, :] *= params_dyna.planning_steps + 1\n",
    "\n",
    "    for i in range(0, len(method_names)):\n",
    "        plt.plot(np.arange(1, num_of_mazes + 1), backups[i, :], label=method_names[i])\n",
    "    plt.xlabel('maze resolution factor')\n",
    "    plt.ylabel('backups until optimal solution')\n",
    "    plt.yscale('log')\n",
    "    plt.legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 0, Prioritized Sweeping, maze size 54\n",
      "run 0, Prioritized Sweeping, maze size 216\n",
      "run 0, Prioritized Sweeping, maze size 486\n",
      "run 0, Prioritized Sweeping, maze size 864\n",
      "run 0, Prioritized Sweeping, maze size 1350\n",
      "run 0, Dyna-Q, maze size 54\n",
      "run 0, Dyna-Q, maze size 216\n",
      "run 0, Dyna-Q, maze size 486\n",
      "run 0, Dyna-Q, maze size 864\n",
      "run 0, Dyna-Q, maze size 1350\n",
      "run 1, Prioritized Sweeping, maze size 54\n",
      "run 1, Prioritized Sweeping, maze size 216\n",
      "run 1, Prioritized Sweeping, maze size 486\n",
      "run 1, Prioritized Sweeping, maze size 864\n",
      "run 1, Prioritized Sweeping, maze size 1350\n",
      "run 1, Dyna-Q, maze size 54\n",
      "run 1, Dyna-Q, maze size 216\n",
      "run 1, Dyna-Q, maze size 486\n",
      "run 1, Dyna-Q, maze size 864\n",
      "run 1, Dyna-Q, maze size 1350\n",
      "run 2, Prioritized Sweeping, maze size 54\n",
      "run 2, Prioritized Sweeping, maze size 216\n",
      "run 2, Prioritized Sweeping, maze size 486\n",
      "run 2, Prioritized Sweeping, maze size 864\n",
      "run 2, Prioritized Sweeping, maze size 1350\n",
      "run 2, Dyna-Q, maze size 54\n",
      "run 2, Dyna-Q, maze size 216\n",
      "run 2, Dyna-Q, maze size 486\n",
      "run 2, Dyna-Q, maze size 864\n",
      "run 2, Dyna-Q, maze size 1350\n",
      "run 3, Prioritized Sweeping, maze size 54\n",
      "run 3, Prioritized Sweeping, maze size 216\n",
      "run 3, Prioritized Sweeping, maze size 486\n",
      "run 3, Prioritized Sweeping, maze size 864\n",
      "run 3, Prioritized Sweeping, maze size 1350\n",
      "run 3, Dyna-Q, maze size 54\n",
      "run 3, Dyna-Q, maze size 216\n",
      "run 3, Dyna-Q, maze size 486\n",
      "run 3, Dyna-Q, maze size 864\n",
      "run 3, Dyna-Q, maze size 1350\n",
      "run 4, Prioritized Sweeping, maze size 54\n",
      "run 4, Prioritized Sweeping, maze size 216\n",
      "run 4, Prioritized Sweeping, maze size 486\n",
      "run 4, Prioritized Sweeping, maze size 864\n",
      "run 4, Prioritized Sweeping, maze size 1350\n",
      "run 4, Dyna-Q, maze size 54\n",
      "run 4, Dyna-Q, maze size 216\n",
      "run 4, Dyna-Q, maze size 486\n",
      "run 4, Dyna-Q, maze size 864\n",
      "run 4, Dyna-Q, maze size 1350\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "example_8_4()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rl",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
